ChasteParameters.hpp

// Copyright (C) 2005-2007 Code Synthesis Tools CC
//
// This program was generated by XML Schema Definition Compiler (XSD)
//
// 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 CHASTE_PARAMETERS_HPP
#define CHASTE_PARAMETERS_HPP

#include <xsd/cxx/version.hxx>

#if (XSD_INT_VERSION != 2030100L)
#error XSD runtime version mismatch
#endif

// Begin prologue.
//
#define COVERAGE_IGNORE
//
// End prologue.

#include <xsd/cxx/pre.hxx>

#ifndef XSD_USE_CHAR
#define XSD_USE_CHAR
#endif

#ifndef XSD_CXX_TREE_USE_CHAR
#define XSD_CXX_TREE_USE_CHAR
#endif

#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/tree/parsing.hxx>

#include <xsd/cxx/tree/serialization.hxx>
#include <xsd/cxx/xml/dom/namespace-infomap.hxx>

namespace xml_schema
{
  // anyType and anySimpleType.
  //
  typedef ::xsd::cxx::tree::type type;
  typedef ::xsd::cxx::tree::simple_type<type> simple_type;

  // 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 integer non_positive_integer;
  typedef integer non_negative_integer;
  typedef integer positive_integer;
  typedef integer negative_integer;

  // Boolean.
  //
  typedef bool boolean;

  // Floating-point types.
  //
  typedef float float_;
  typedef double double_;
  typedef long 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< type, char, ncname > 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::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::day< char, simple_type > day;
  typedef ::xsd::cxx::tree::month< char, simple_type > month;
  typedef ::xsd::cxx::tree::month_day< char, simple_type > month_day;
  typedef ::xsd::cxx::tree::year< char, simple_type > year;
  typedef ::xsd::cxx::tree::year_month< char, simple_type > year_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;

  // Exceptions.
  //
  typedef ::xsd::cxx::tree::exception< char > exception;
  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_type_info< char > no_type_info;
  typedef ::xsd::cxx::tree::not_derived< char > not_derived;
  typedef ::xsd::cxx::tree::duplicate_id< char > duplicate_id;
  typedef ::xsd::cxx::tree::serialization< char > serialization;
  typedef ::xsd::cxx::tree::no_namespace_mapping< char > no_namespace_mapping;
  typedef ::xsd::cxx::tree::no_prefix_mapping< char > no_prefix_mapping;
  typedef ::xsd::cxx::tree::xsi_already_in_use< char > xsi_already_in_use;
  typedef ::xsd::cxx::tree::bounds< char > bounds;

  // Parsing/serialization error.
  //
  typedef ::xsd::cxx::tree::error< char > error;
  typedef ::xsd::cxx::tree::errors< char > errors;

  // Error handler interface.
  //
  typedef ::xsd::cxx::xml::error_handler< char > error_handler;

  // Namespace information. Used in serialization functions.
  //
  typedef ::xsd::cxx::xml::dom::namespace_info < char > namespace_info;
  typedef ::xsd::cxx::xml::dom::namespace_infomap < char > namespace_infomap;

  // Flags and properties.
  //
  typedef ::xsd::cxx::tree::flags flags;
  typedef ::xsd::cxx::tree::properties< char > properties;

  // DOM user data key for back pointers to tree nodes.
  //
#ifndef XSD_CXX_TREE_TREE_NODE_KEY_IN___XML_SCHEMA
#define XSD_CXX_TREE_TREE_NODE_KEY_IN___XML_SCHEMA

  const XMLCh* const tree_node_key = ::xsd::cxx::tree::user_data_keys::node;

#endif
}

// Forward declarations.
//
class time_type;
class dimensionless_type;
class conductivity_type;
class stimulus_strength_type;
class inverse_length_type;
class capacitance_type;
class location_type;
class domain_type;
class ionic_models_available_type;
class ionic_model_region_type;
class ionic_models_type;
class media_type;
class point_type;
class box_type;
class stimulus_type;
class cell_heterogeneity_type;
class conductivity_heterogeneity_type;
class slab_type;
class sheet_type;
class fibre_type;
class load_mesh_type;
class mesh_type;
class conductivities_type;
class time_steps_type;
class ksp_use_type;
class ksp_tolerances_type;
class ksp_solver_type;
class ksp_preconditioner_type;
class simulation_type;
class physiological_type;
class numerical_type;
class chaste_parameters_type;

#include <memory>    // std::auto_ptr
#include <algorithm> // std::binary_search

#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/containers.hxx>
#include <xsd/cxx/tree/list.hxx>

class time_type: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::decimal, char, ::xml_schema::simple_type >
{
  public:

  struct _xsd_time_type
  {
    typedef ::xml_schema::decimal base_;
  };

  // unit
  // 
  public:
  struct unit
  {
    typedef ::xml_schema::string type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;

    static const type&
    default_value ();

    private:
    static const type default_value_;
  };

  const unit::type&
  unit () const;

  unit::type&
  unit ();

  void
  unit (const unit::type&);

  void
  unit (::std::auto_ptr< unit::type >);

  // Constructors.
  //
  public:
  time_type (const _xsd_time_type::base_& ,
             const unit::type&);

  time_type (const ::xercesc::DOMElement&,
             ::xml_schema::flags = 0,
             ::xml_schema::type* = 0);

  time_type (const time_type&,
             ::xml_schema::flags = 0,
             ::xml_schema::type* = 0);

  virtual time_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< unit::type > _xsd_unit_;
};

class dimensionless_type: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::decimal, char, ::xml_schema::simple_type >
{
  public:

  struct _xsd_dimensionless_type
  {
    typedef ::xml_schema::decimal base_;
  };

  // unit
  // 
  public:
  struct unit
  {
    typedef ::xml_schema::string type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;

    static const type&
    default_value ();

    private:
    static const type default_value_;
  };

  const unit::type&
  unit () const;

  unit::type&
  unit ();

  void
  unit (const unit::type&);

  void
  unit (::std::auto_ptr< unit::type >);

  // Constructors.
  //
  public:
  dimensionless_type (const _xsd_dimensionless_type::base_& ,
                      const unit::type&);

  dimensionless_type (const ::xercesc::DOMElement&,
                      ::xml_schema::flags = 0,
                      ::xml_schema::type* = 0);

  dimensionless_type (const dimensionless_type&,
                      ::xml_schema::flags = 0,
                      ::xml_schema::type* = 0);

  virtual dimensionless_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< unit::type > _xsd_unit_;
};

class conductivity_type: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::decimal, char, ::xml_schema::simple_type >
{
  public:

  struct _xsd_conductivity_type
  {
    typedef ::xml_schema::decimal base_;
  };

  // unit
  // 
  public:
  struct unit
  {
    typedef ::xml_schema::string type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;

    static const type&
    default_value ();

    private:
    static const type default_value_;
  };

  const unit::type&
  unit () const;

  unit::type&
  unit ();

  void
  unit (const unit::type&);

  void
  unit (::std::auto_ptr< unit::type >);

  // Constructors.
  //
  public:
  conductivity_type (const _xsd_conductivity_type::base_& ,
                     const unit::type&);

  conductivity_type (const ::xercesc::DOMElement&,
                     ::xml_schema::flags = 0,
                     ::xml_schema::type* = 0);

  conductivity_type (const conductivity_type&,
                     ::xml_schema::flags = 0,
                     ::xml_schema::type* = 0);

  virtual conductivity_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< unit::type > _xsd_unit_;
};

class stimulus_strength_type: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::decimal, char, ::xml_schema::simple_type >
{
  public:

  struct _xsd_stimulus_strength_type
  {
    typedef ::xml_schema::decimal base_;
  };

  // unit
  // 
  public:
  struct unit
  {
    typedef ::xml_schema::string type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;

    static const type&
    default_value ();

    private:
    static const type default_value_;
  };

  const unit::type&
  unit () const;

  unit::type&
  unit ();

  void
  unit (const unit::type&);

  void
  unit (::std::auto_ptr< unit::type >);

  // Constructors.
  //
  public:
  stimulus_strength_type (const _xsd_stimulus_strength_type::base_& ,
                          const unit::type&);

  stimulus_strength_type (const ::xercesc::DOMElement&,
                          ::xml_schema::flags = 0,
                          ::xml_schema::type* = 0);

  stimulus_strength_type (const stimulus_strength_type&,
                          ::xml_schema::flags = 0,
                          ::xml_schema::type* = 0);

  virtual stimulus_strength_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< unit::type > _xsd_unit_;
};

class inverse_length_type: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::decimal, char, ::xml_schema::simple_type >
{
  public:

  struct _xsd_inverse_length_type
  {
    typedef ::xml_schema::decimal base_;
  };

  // unit
  // 
  public:
  struct unit
  {
    typedef ::xml_schema::string type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;

    static const type&
    default_value ();

    private:
    static const type default_value_;
  };

  const unit::type&
  unit () const;

  unit::type&
  unit ();

  void
  unit (const unit::type&);

  void
  unit (::std::auto_ptr< unit::type >);

  // Constructors.
  //
  public:
  inverse_length_type (const _xsd_inverse_length_type::base_& ,
                       const unit::type&);

  inverse_length_type (const ::xercesc::DOMElement&,
                       ::xml_schema::flags = 0,
                       ::xml_schema::type* = 0);

  inverse_length_type (const inverse_length_type&,
                       ::xml_schema::flags = 0,
                       ::xml_schema::type* = 0);

  virtual inverse_length_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< unit::type > _xsd_unit_;
};

class capacitance_type: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::decimal, char, ::xml_schema::simple_type >
{
  public:

  struct _xsd_capacitance_type
  {
    typedef ::xml_schema::decimal base_;
  };

  // unit
  // 
  public:
  struct unit
  {
    typedef ::xml_schema::string type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;

    static const type&
    default_value ();

    private:
    static const type default_value_;
  };

  const unit::type&
  unit () const;

  unit::type&
  unit ();

  void
  unit (const unit::type&);

  void
  unit (::std::auto_ptr< unit::type >);

  // Constructors.
  //
  public:
  capacitance_type (const _xsd_capacitance_type::base_& ,
                    const unit::type&);

  capacitance_type (const ::xercesc::DOMElement&,
                    ::xml_schema::flags = 0,
                    ::xml_schema::type* = 0);

  capacitance_type (const capacitance_type&,
                    ::xml_schema::flags = 0,
                    ::xml_schema::type* = 0);

  virtual capacitance_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< unit::type > _xsd_unit_;
};

class location_type: public ::xml_schema::type
{
  public:

  struct _xsd_location_type
  {
    typedef ::xml_schema::type base_;
  };

  // Cuboid
  // 
  public:
  struct Cuboid
  {
    typedef ::box_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const Cuboid::type&
  Cuboid () const;

  Cuboid::type&
  Cuboid ();

  void
  Cuboid (const Cuboid::type&);

  void
  Cuboid (::std::auto_ptr< Cuboid::type >);

  // unit
  // 
  public:
  struct unit
  {
    typedef ::xml_schema::string type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;

    static const type&
    default_value ();

    private:
    static const type default_value_;
  };

  const unit::type&
  unit () const;

  unit::type&
  unit ();

  void
  unit (const unit::type&);

  void
  unit (::std::auto_ptr< unit::type >);

  // Constructors.
  //
  public:
  location_type (const Cuboid::type&,
                 const unit::type&);

  location_type (const ::xercesc::DOMElement&,
                 ::xml_schema::flags = 0,
                 ::xml_schema::type* = 0);

  location_type (const location_type&,
                 ::xml_schema::flags = 0,
                 ::xml_schema::type* = 0);

  virtual location_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< Cuboid::type > _xsd_Cuboid_;
  ::xsd::cxx::tree::one< unit::type > _xsd_unit_;
};

class domain_type: public ::xml_schema::string
{
  public:
  enum _xsd_domain_type
  {
    Mono,
    Bi
  };

  domain_type (_xsd_domain_type);

  domain_type (const ::xml_schema::string&);

  domain_type (const ::xercesc::DOMElement&,
               ::xml_schema::flags = 0,
               ::xml_schema::type* = 0);

  domain_type (const ::xercesc::DOMAttr&,
               ::xml_schema::flags = 0,
               ::xml_schema::type* = 0);

  domain_type (const ::std::basic_string< char >&,
               const ::xercesc::DOMElement*,
               ::xml_schema::flags = 0,
               ::xml_schema::type* = 0);

  domain_type (const domain_type&,
               ::xml_schema::flags = 0,
               ::xml_schema::type* = 0);

  virtual domain_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  domain_type&
  operator= (_xsd_domain_type);

  virtual
  operator _xsd_domain_type () const
  {
    return _xsd_domain_type_convert ();
  }

  protected:
  _xsd_domain_type
  _xsd_domain_type_convert () const;

  public:
  static const char* const _xsd_domain_type_literals_[2];
  static const _xsd_domain_type _xsd_domain_type_indexes_[2];
};

class ionic_models_available_type: public ::xml_schema::string
{
  public:
  enum _xsd_ionic_models_available_type
  {
    Fox2002BackwardEuler,
    LuoRudyIBackwardEuler,
    LuoRudyI,
    FaberRudy2000Optimised,
    FaberRudy2000,
    DifrancescoNoble,
    MahajanShiferaw,
    HodgkinHuxley,
    tenTusscher2006
  };

  ionic_models_available_type (_xsd_ionic_models_available_type);

  ionic_models_available_type (const ::xml_schema::string&);

  ionic_models_available_type (const ::xercesc::DOMElement&,
                               ::xml_schema::flags = 0,
                               ::xml_schema::type* = 0);

  ionic_models_available_type (const ::xercesc::DOMAttr&,
                               ::xml_schema::flags = 0,
                               ::xml_schema::type* = 0);

  ionic_models_available_type (const ::std::basic_string< char >&,
                               const ::xercesc::DOMElement*,
                               ::xml_schema::flags = 0,
                               ::xml_schema::type* = 0);

  ionic_models_available_type (const ionic_models_available_type&,
                               ::xml_schema::flags = 0,
                               ::xml_schema::type* = 0);

  virtual ionic_models_available_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  ionic_models_available_type&
  operator= (_xsd_ionic_models_available_type);

  virtual
  operator _xsd_ionic_models_available_type () const
  {
    return _xsd_ionic_models_available_type_convert ();
  }

  protected:
  _xsd_ionic_models_available_type
  _xsd_ionic_models_available_type_convert () const;

  public:
  static const char* const _xsd_ionic_models_available_type_literals_[9];
  static const _xsd_ionic_models_available_type _xsd_ionic_models_available_type_indexes_[9];
};

class ionic_model_region_type: public ::xml_schema::type
{
  public:

  struct _xsd_ionic_model_region_type
  {
    typedef ::xml_schema::type base_;
  };

  // IonicModel
  // 
  public:
  struct IonicModel
  {
    typedef ::ionic_models_available_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const IonicModel::type&
  IonicModel () const;

  IonicModel::type&
  IonicModel ();

  void
  IonicModel (const IonicModel::type&);

  void
  IonicModel (::std::auto_ptr< IonicModel::type >);

  // Location
  // 
  public:
  struct Location
  {
    typedef ::location_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const Location::type&
  Location () const;

  Location::type&
  Location ();

  void
  Location (const Location::type&);

  void
  Location (::std::auto_ptr< Location::type >);

  // Constructors.
  //
  public:
  ionic_model_region_type (const IonicModel::type&,
                           const Location::type&);

  ionic_model_region_type (const ::xercesc::DOMElement&,
                           ::xml_schema::flags = 0,
                           ::xml_schema::type* = 0);

  ionic_model_region_type (const ionic_model_region_type&,
                           ::xml_schema::flags = 0,
                           ::xml_schema::type* = 0);

  virtual ionic_model_region_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< IonicModel::type > _xsd_IonicModel_;
  ::xsd::cxx::tree::one< Location::type > _xsd_Location_;
};

class ionic_models_type: public ::xml_schema::type
{
  public:

  struct _xsd_ionic_models_type
  {
    typedef ::xml_schema::type base_;
  };

  // Default
  // 
  public:
  struct Default
  {
    typedef ::ionic_models_available_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const Default::type&
  Default () const;

  Default::type&
  Default ();

  void
  Default (const Default::type&);

  void
  Default (::std::auto_ptr< Default::type >);

  // Region
  // 
  public:
  struct Region
  {
    typedef ::ionic_model_region_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::sequence< type > container;
    typedef container::iterator iterator;
    typedef container::const_iterator const_iterator;
  };

  const Region::container&
  Region () const;

  Region::container&
  Region ();

  void
  Region (const Region::container&);

  // Constructors.
  //
  public:
  ionic_models_type (const Default::type&);

  ionic_models_type (const ::xercesc::DOMElement&,
                     ::xml_schema::flags = 0,
                     ::xml_schema::type* = 0);

  ionic_models_type (const ionic_models_type&,
                     ::xml_schema::flags = 0,
                     ::xml_schema::type* = 0);

  virtual ionic_models_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< Default::type > _xsd_Default_;
  ::xsd::cxx::tree::sequence< Region::type > _xsd_Region_;
};

class media_type: public ::xml_schema::string
{
  public:
  enum _xsd_media_type
  {
    Orthotropic,
    Axisymmetric,
    NoFibreOrientation
  };

  media_type (_xsd_media_type);

  media_type (const ::xml_schema::string&);

  media_type (const ::xercesc::DOMElement&,
              ::xml_schema::flags = 0,
              ::xml_schema::type* = 0);

  media_type (const ::xercesc::DOMAttr&,
              ::xml_schema::flags = 0,
              ::xml_schema::type* = 0);

  media_type (const ::std::basic_string< char >&,
              const ::xercesc::DOMElement*,
              ::xml_schema::flags = 0,
              ::xml_schema::type* = 0);

  media_type (const media_type&,
              ::xml_schema::flags = 0,
              ::xml_schema::type* = 0);

  virtual media_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  media_type&
  operator= (_xsd_media_type);

  virtual
  operator _xsd_media_type () const
  {
    return _xsd_media_type_convert ();
  }

  protected:
  _xsd_media_type
  _xsd_media_type_convert () const;

  public:
  static const char* const _xsd_media_type_literals_[3];
  static const _xsd_media_type _xsd_media_type_indexes_[3];
};

class point_type: public ::xml_schema::type
{
  public:

  struct _xsd_point_type
  {
    typedef ::xml_schema::type base_;
  };

  // x
  // 
  public:
  struct x
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const x::type&
  x () const;

  x::type&
  x ();

  void
  x (const x::type&);

  // y
  // 
  public:
  struct y
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const y::type&
  y () const;

  y::type&
  y ();

  void
  y (const y::type&);

  // z
  // 
  public:
  struct z
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const z::type&
  z () const;

  z::type&
  z ();

  void
  z (const z::type&);

  // Constructors.
  //
  public:
  point_type (const x::type&,
              const y::type&,
              const z::type&);

  point_type (const ::xercesc::DOMElement&,
              ::xml_schema::flags = 0,
              ::xml_schema::type* = 0);

  point_type (const point_type&,
              ::xml_schema::flags = 0,
              ::xml_schema::type* = 0);

  virtual point_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< x::type > _xsd_x_;
  ::xsd::cxx::tree::one< y::type > _xsd_y_;
  ::xsd::cxx::tree::one< z::type > _xsd_z_;
};

class box_type: public ::xml_schema::type
{
  public:

  struct _xsd_box_type
  {
    typedef ::xml_schema::type base_;
  };

  // LowerCoordinates
  // 
  public:
  struct LowerCoordinates
  {
    typedef ::point_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const LowerCoordinates::type&
  LowerCoordinates () const;

  LowerCoordinates::type&
  LowerCoordinates ();

  void
  LowerCoordinates (const LowerCoordinates::type&);

  void
  LowerCoordinates (::std::auto_ptr< LowerCoordinates::type >);

  // UpperCoordinates
  // 
  public:
  struct UpperCoordinates
  {
    typedef ::point_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const UpperCoordinates::type&
  UpperCoordinates () const;

  UpperCoordinates::type&
  UpperCoordinates ();

  void
  UpperCoordinates (const UpperCoordinates::type&);

  void
  UpperCoordinates (::std::auto_ptr< UpperCoordinates::type >);

  // Constructors.
  //
  public:
  box_type (const LowerCoordinates::type&,
            const UpperCoordinates::type&);

  box_type (const ::xercesc::DOMElement&,
            ::xml_schema::flags = 0,
            ::xml_schema::type* = 0);

  box_type (const box_type&,
            ::xml_schema::flags = 0,
            ::xml_schema::type* = 0);

  virtual box_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< LowerCoordinates::type > _xsd_LowerCoordinates_;
  ::xsd::cxx::tree::one< UpperCoordinates::type > _xsd_UpperCoordinates_;
};

class stimulus_type: public ::xml_schema::type
{
  public:

  struct _xsd_stimulus_type
  {
    typedef ::xml_schema::type base_;
  };

  // Strength
  // 
  public:
  struct Strength
  {
    typedef ::stimulus_strength_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const Strength::type&
  Strength () const;

  Strength::type&
  Strength ();

  void
  Strength (const Strength::type&);

  void
  Strength (::std::auto_ptr< Strength::type >);

  // Duration
  // 
  public:
  struct Duration
  {
    typedef ::time_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const Duration::type&
  Duration () const;

  Duration::type&
  Duration ();

  void
  Duration (const Duration::type&);

  void
  Duration (::std::auto_ptr< Duration::type >);

  // Delay
  // 
  public:
  struct Delay
  {
    typedef ::time_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const Delay::type&
  Delay () const;

  Delay::type&
  Delay ();

  void
  Delay (const Delay::type&);

  void
  Delay (::std::auto_ptr< Delay::type >);

  // Location
  // 
  public:
  struct Location
  {
    typedef ::location_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const Location::type&
  Location () const;

  Location::type&
  Location ();

  void
  Location (const Location::type&);

  void
  Location (::std::auto_ptr< Location::type >);

  // Constructors.
  //
  public:
  stimulus_type (const Strength::type&,
                 const Duration::type&,
                 const Delay::type&,
                 const Location::type&);

  stimulus_type (const ::xercesc::DOMElement&,
                 ::xml_schema::flags = 0,
                 ::xml_schema::type* = 0);

  stimulus_type (const stimulus_type&,
                 ::xml_schema::flags = 0,
                 ::xml_schema::type* = 0);

  virtual stimulus_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< Strength::type > _xsd_Strength_;
  ::xsd::cxx::tree::one< Duration::type > _xsd_Duration_;
  ::xsd::cxx::tree::one< Delay::type > _xsd_Delay_;
  ::xsd::cxx::tree::one< Location::type > _xsd_Location_;
};

class cell_heterogeneity_type: public ::xml_schema::type
{
  public:

  struct _xsd_cell_heterogeneity_type
  {
    typedef ::xml_schema::type base_;
  };

  // ScaleFactorGks
  // 
  public:
  struct ScaleFactorGks
  {
    typedef ::dimensionless_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const ScaleFactorGks::type&
  ScaleFactorGks () const;

  ScaleFactorGks::type&
  ScaleFactorGks ();

  void
  ScaleFactorGks (const ScaleFactorGks::type&);

  void
  ScaleFactorGks (::std::auto_ptr< ScaleFactorGks::type >);

  // ScaleFactorIto
  // 
  public:
  struct ScaleFactorIto
  {
    typedef ::dimensionless_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const ScaleFactorIto::type&
  ScaleFactorIto () const;

  ScaleFactorIto::type&
  ScaleFactorIto ();

  void
  ScaleFactorIto (const ScaleFactorIto::type&);

  void
  ScaleFactorIto (::std::auto_ptr< ScaleFactorIto::type >);

  // ScaleFactorGkr
  // 
  public:
  struct ScaleFactorGkr
  {
    typedef ::dimensionless_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const ScaleFactorGkr::type&
  ScaleFactorGkr () const;

  ScaleFactorGkr::type&
  ScaleFactorGkr ();

  void
  ScaleFactorGkr (const ScaleFactorGkr::type&);

  void
  ScaleFactorGkr (::std::auto_ptr< ScaleFactorGkr::type >);

  // Location
  // 
  public:
  struct Location
  {
    typedef ::location_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const Location::type&
  Location () const;

  Location::type&
  Location ();

  void
  Location (const Location::type&);

  void
  Location (::std::auto_ptr< Location::type >);

  // Constructors.
  //
  public:
  cell_heterogeneity_type (const ScaleFactorGks::type&,
                           const ScaleFactorIto::type&,
                           const ScaleFactorGkr::type&,
                           const Location::type&);

  cell_heterogeneity_type (const ::xercesc::DOMElement&,
                           ::xml_schema::flags = 0,
                           ::xml_schema::type* = 0);

  cell_heterogeneity_type (const cell_heterogeneity_type&,
                           ::xml_schema::flags = 0,
                           ::xml_schema::type* = 0);

  virtual cell_heterogeneity_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< ScaleFactorGks::type > _xsd_ScaleFactorGks_;
  ::xsd::cxx::tree::one< ScaleFactorIto::type > _xsd_ScaleFactorIto_;
  ::xsd::cxx::tree::one< ScaleFactorGkr::type > _xsd_ScaleFactorGkr_;
  ::xsd::cxx::tree::one< Location::type > _xsd_Location_;
};

class conductivity_heterogeneity_type: public ::xml_schema::type
{
  public:

  struct _xsd_conductivity_heterogeneity_type
  {
    typedef ::xml_schema::type base_;
  };

  // IntracellularConductivities
  // 
  public:
  struct IntracellularConductivities
  {
    typedef ::conductivities_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const IntracellularConductivities::container&
  IntracellularConductivities () const;

  IntracellularConductivities::container&
  IntracellularConductivities ();

  void
  IntracellularConductivities (const IntracellularConductivities::type&);

  void
  IntracellularConductivities (const IntracellularConductivities::container&);

  void
  IntracellularConductivities (::std::auto_ptr< IntracellularConductivities::type >);

  // ExtracellularConductivities
  // 
  public:
  struct ExtracellularConductivities
  {
    typedef ::conductivities_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const ExtracellularConductivities::container&
  ExtracellularConductivities () const;

  ExtracellularConductivities::container&
  ExtracellularConductivities ();

  void
  ExtracellularConductivities (const ExtracellularConductivities::type&);

  void
  ExtracellularConductivities (const ExtracellularConductivities::container&);

  void
  ExtracellularConductivities (::std::auto_ptr< ExtracellularConductivities::type >);

  // Location
  // 
  public:
  struct Location
  {
    typedef ::location_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const Location::type&
  Location () const;

  Location::type&
  Location ();

  void
  Location (const Location::type&);

  void
  Location (::std::auto_ptr< Location::type >);

  // Constructors.
  //
  public:
  conductivity_heterogeneity_type (const Location::type&);

  conductivity_heterogeneity_type (const ::xercesc::DOMElement&,
                                   ::xml_schema::flags = 0,
                                   ::xml_schema::type* = 0);

  conductivity_heterogeneity_type (const conductivity_heterogeneity_type&,
                                   ::xml_schema::flags = 0,
                                   ::xml_schema::type* = 0);

  virtual conductivity_heterogeneity_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::optional< IntracellularConductivities::type > _xsd_IntracellularConductivities_;
  ::xsd::cxx::tree::optional< ExtracellularConductivities::type > _xsd_ExtracellularConductivities_;
  ::xsd::cxx::tree::one< Location::type > _xsd_Location_;
};

class slab_type: public ::xml_schema::type
{
  public:

  struct _xsd_slab_type
  {
    typedef ::xml_schema::type base_;
  };

  // x
  // 
  public:
  struct x
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const x::type&
  x () const;

  x::type&
  x ();

  void
  x (const x::type&);

  // y
  // 
  public:
  struct y
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const y::type&
  y () const;

  y::type&
  y ();

  void
  y (const y::type&);

  // z
  // 
  public:
  struct z
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const z::type&
  z () const;

  z::type&
  z ();

  void
  z (const z::type&);

  // inter_node_space
  // 
  public:
  struct inter_node_space
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const inter_node_space::type&
  inter_node_space () const;

  inter_node_space::type&
  inter_node_space ();

  void
  inter_node_space (const inter_node_space::type&);

  // Constructors.
  //
  public:
  slab_type (const x::type&,
             const y::type&,
             const z::type&,
             const inter_node_space::type&);

  slab_type (const ::xercesc::DOMElement&,
             ::xml_schema::flags = 0,
             ::xml_schema::type* = 0);

  slab_type (const slab_type&,
             ::xml_schema::flags = 0,
             ::xml_schema::type* = 0);

  virtual slab_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< x::type > _xsd_x_;
  ::xsd::cxx::tree::one< y::type > _xsd_y_;
  ::xsd::cxx::tree::one< z::type > _xsd_z_;
  ::xsd::cxx::tree::one< inter_node_space::type > _xsd_inter_node_space_;
};

class sheet_type: public ::xml_schema::type
{
  public:

  struct _xsd_sheet_type
  {
    typedef ::xml_schema::type base_;
  };

  // x
  // 
  public:
  struct x
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const x::type&
  x () const;

  x::type&
  x ();

  void
  x (const x::type&);

  // y
  // 
  public:
  struct y
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const y::type&
  y () const;

  y::type&
  y ();

  void
  y (const y::type&);

  // inter_node_space
  // 
  public:
  struct inter_node_space
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const inter_node_space::type&
  inter_node_space () const;

  inter_node_space::type&
  inter_node_space ();

  void
  inter_node_space (const inter_node_space::type&);

  // Constructors.
  //
  public:
  sheet_type (const x::type&,
              const y::type&,
              const inter_node_space::type&);

  sheet_type (const ::xercesc::DOMElement&,
              ::xml_schema::flags = 0,
              ::xml_schema::type* = 0);

  sheet_type (const sheet_type&,
              ::xml_schema::flags = 0,
              ::xml_schema::type* = 0);

  virtual sheet_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< x::type > _xsd_x_;
  ::xsd::cxx::tree::one< y::type > _xsd_y_;
  ::xsd::cxx::tree::one< inter_node_space::type > _xsd_inter_node_space_;
};

class fibre_type: public ::xml_schema::type
{
  public:

  struct _xsd_fibre_type
  {
    typedef ::xml_schema::type base_;
  };

  // x
  // 
  public:
  struct x
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const x::type&
  x () const;

  x::type&
  x ();

  void
  x (const x::type&);

  // inter_node_space
  // 
  public:
  struct inter_node_space
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const inter_node_space::type&
  inter_node_space () const;

  inter_node_space::type&
  inter_node_space ();

  void
  inter_node_space (const inter_node_space::type&);

  // Constructors.
  //
  public:
  fibre_type (const x::type&,
              const inter_node_space::type&);

  fibre_type (const ::xercesc::DOMElement&,
              ::xml_schema::flags = 0,
              ::xml_schema::type* = 0);

  fibre_type (const fibre_type&,
              ::xml_schema::flags = 0,
              ::xml_schema::type* = 0);

  virtual fibre_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< x::type > _xsd_x_;
  ::xsd::cxx::tree::one< inter_node_space::type > _xsd_inter_node_space_;
};

class load_mesh_type: public ::xml_schema::type
{
  public:

  struct _xsd_load_mesh_type
  {
    typedef ::xml_schema::type base_;
  };

  // name
  // 
  public:
  struct name
  {
    typedef ::xml_schema::string type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const name::type&
  name () const;

  name::type&
  name ();

  void
  name (const name::type&);

  void
  name (::std::auto_ptr< name::type >);

  // conductivity_media
  // 
  public:
  struct conductivity_media
  {
    typedef ::media_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const conductivity_media::type&
  conductivity_media () const;

  conductivity_media::type&
  conductivity_media ();

  void
  conductivity_media (const conductivity_media::type&);

  void
  conductivity_media (::std::auto_ptr< conductivity_media::type >);

  // Constructors.
  //
  public:
  load_mesh_type (const name::type&,
                  const conductivity_media::type&);

  load_mesh_type (const ::xercesc::DOMElement&,
                  ::xml_schema::flags = 0,
                  ::xml_schema::type* = 0);

  load_mesh_type (const load_mesh_type&,
                  ::xml_schema::flags = 0,
                  ::xml_schema::type* = 0);

  virtual load_mesh_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< name::type > _xsd_name_;
  ::xsd::cxx::tree::one< conductivity_media::type > _xsd_conductivity_media_;
};

class mesh_type: public ::xml_schema::type
{
  public:

  struct _xsd_mesh_type
  {
    typedef ::xml_schema::type base_;
  };

  // Slab
  // 
  public:
  struct Slab
  {
    typedef ::slab_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const Slab::container&
  Slab () const;

  Slab::container&
  Slab ();

  void
  Slab (const Slab::type&);

  void
  Slab (const Slab::container&);

  void
  Slab (::std::auto_ptr< Slab::type >);

  // Sheet
  // 
  public:
  struct Sheet
  {
    typedef ::sheet_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const Sheet::container&
  Sheet () const;

  Sheet::container&
  Sheet ();

  void
  Sheet (const Sheet::type&);

  void
  Sheet (const Sheet::container&);

  void
  Sheet (::std::auto_ptr< Sheet::type >);

  // Fibre
  // 
  public:
  struct Fibre
  {
    typedef ::fibre_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const Fibre::container&
  Fibre () const;

  Fibre::container&
  Fibre ();

  void
  Fibre (const Fibre::type&);

  void
  Fibre (const Fibre::container&);

  void
  Fibre (::std::auto_ptr< Fibre::type >);

  // LoadMesh
  // 
  public:
  struct LoadMesh
  {
    typedef ::load_mesh_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const LoadMesh::container&
  LoadMesh () const;

  LoadMesh::container&
  LoadMesh ();

  void
  LoadMesh (const LoadMesh::type&);

  void
  LoadMesh (const LoadMesh::container&);

  void
  LoadMesh (::std::auto_ptr< LoadMesh::type >);

  // unit
  // 
  public:
  struct unit
  {
    typedef ::xml_schema::string type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;

    static const type&
    default_value ();

    private:
    static const type default_value_;
  };

  const unit::type&
  unit () const;

  unit::type&
  unit ();

  void
  unit (const unit::type&);

  void
  unit (::std::auto_ptr< unit::type >);

  // Constructors.
  //
  public:
  mesh_type (const unit::type&);

  mesh_type (const ::xercesc::DOMElement&,
             ::xml_schema::flags = 0,
             ::xml_schema::type* = 0);

  mesh_type (const mesh_type&,
             ::xml_schema::flags = 0,
             ::xml_schema::type* = 0);

  virtual mesh_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::optional< Slab::type > _xsd_Slab_;
  ::xsd::cxx::tree::optional< Sheet::type > _xsd_Sheet_;
  ::xsd::cxx::tree::optional< Fibre::type > _xsd_Fibre_;
  ::xsd::cxx::tree::optional< LoadMesh::type > _xsd_LoadMesh_;
  ::xsd::cxx::tree::one< unit::type > _xsd_unit_;
};

class conductivities_type: public ::xml_schema::type
{
  public:

  struct _xsd_conductivities_type
  {
    typedef ::xml_schema::type base_;
  };

  // longi
  // 
  public:
  struct longi
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const longi::type&
  longi () const;

  longi::type&
  longi ();

  void
  longi (const longi::type&);

  // trans
  // 
  public:
  struct trans
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const trans::type&
  trans () const;

  trans::type&
  trans ();

  void
  trans (const trans::type&);

  // normal
  // 
  public:
  struct normal
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const normal::type&
  normal () const;

  normal::type&
  normal ();

  void
  normal (const normal::type&);

  // unit
  // 
  public:
  struct unit
  {
    typedef ::xml_schema::string type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;

    static const type&
    default_value ();

    private:
    static const type default_value_;
  };

  const unit::type&
  unit () const;

  unit::type&
  unit ();

  void
  unit (const unit::type&);

  void
  unit (::std::auto_ptr< unit::type >);

  // Constructors.
  //
  public:
  conductivities_type (const longi::type&,
                       const trans::type&,
                       const normal::type&,
                       const unit::type&);

  conductivities_type (const ::xercesc::DOMElement&,
                       ::xml_schema::flags = 0,
                       ::xml_schema::type* = 0);

  conductivities_type (const conductivities_type&,
                       ::xml_schema::flags = 0,
                       ::xml_schema::type* = 0);

  virtual conductivities_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< longi::type > _xsd_longi_;
  ::xsd::cxx::tree::one< trans::type > _xsd_trans_;
  ::xsd::cxx::tree::one< normal::type > _xsd_normal_;
  ::xsd::cxx::tree::one< unit::type > _xsd_unit_;
};

class time_steps_type: public ::xml_schema::type
{
  public:

  struct _xsd_time_steps_type
  {
    typedef ::xml_schema::type base_;
  };

  // ode
  // 
  public:
  struct ode
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const ode::type&
  ode () const;

  ode::type&
  ode ();

  void
  ode (const ode::type&);

  // pde
  // 
  public:
  struct pde
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const pde::type&
  pde () const;

  pde::type&
  pde ();

  void
  pde (const pde::type&);

  // printing
  // 
  public:
  struct printing
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const printing::type&
  printing () const;

  printing::type&
  printing ();

  void
  printing (const printing::type&);

  // unit
  // 
  public:
  struct unit
  {
    typedef ::xml_schema::string type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;

    static const type&
    default_value ();

    private:
    static const type default_value_;
  };

  const unit::type&
  unit () const;

  unit::type&
  unit ();

  void
  unit (const unit::type&);

  void
  unit (::std::auto_ptr< unit::type >);

  // Constructors.
  //
  public:
  time_steps_type (const ode::type&,
                   const pde::type&,
                   const printing::type&,
                   const unit::type&);

  time_steps_type (const ::xercesc::DOMElement&,
                   ::xml_schema::flags = 0,
                   ::xml_schema::type* = 0);

  time_steps_type (const time_steps_type&,
                   ::xml_schema::flags = 0,
                   ::xml_schema::type* = 0);

  virtual time_steps_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< ode::type > _xsd_ode_;
  ::xsd::cxx::tree::one< pde::type > _xsd_pde_;
  ::xsd::cxx::tree::one< printing::type > _xsd_printing_;
  ::xsd::cxx::tree::one< unit::type > _xsd_unit_;
};

class ksp_use_type: public ::xml_schema::string
{
  public:
  enum _xsd_ksp_use_type
  {
    relative,
    absolute
  };

  ksp_use_type (_xsd_ksp_use_type);

  ksp_use_type (const ::xml_schema::string&);

  ksp_use_type (const ::xercesc::DOMElement&,
                ::xml_schema::flags = 0,
                ::xml_schema::type* = 0);

  ksp_use_type (const ::xercesc::DOMAttr&,
                ::xml_schema::flags = 0,
                ::xml_schema::type* = 0);

  ksp_use_type (const ::std::basic_string< char >&,
                const ::xercesc::DOMElement*,
                ::xml_schema::flags = 0,
                ::xml_schema::type* = 0);

  ksp_use_type (const ksp_use_type&,
                ::xml_schema::flags = 0,
                ::xml_schema::type* = 0);

  virtual ksp_use_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  ksp_use_type&
  operator= (_xsd_ksp_use_type);

  virtual
  operator _xsd_ksp_use_type () const
  {
    return _xsd_ksp_use_type_convert ();
  }

  protected:
  _xsd_ksp_use_type
  _xsd_ksp_use_type_convert () const;

  public:
  static const char* const _xsd_ksp_use_type_literals_[2];
  static const _xsd_ksp_use_type _xsd_ksp_use_type_indexes_[2];
};

class ksp_tolerances_type: public ::xml_schema::type
{
  public:

  struct _xsd_ksp_tolerances_type
  {
    typedef ::xml_schema::type base_;
  };

  // KSPRelative
  // 
  public:
  struct KSPRelative
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const KSPRelative::container&
  KSPRelative () const;

  KSPRelative::container&
  KSPRelative ();

  void
  KSPRelative (const KSPRelative::type&);

  void
  KSPRelative (const KSPRelative::container&);

  // KSPAbsolute
  // 
  public:
  struct KSPAbsolute
  {
    typedef ::xml_schema::double_ type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const KSPAbsolute::container&
  KSPAbsolute () const;

  KSPAbsolute::container&
  KSPAbsolute ();

  void
  KSPAbsolute (const KSPAbsolute::type&);

  void
  KSPAbsolute (const KSPAbsolute::container&);

  // Constructors.
  //
  public:
  ksp_tolerances_type ();

  ksp_tolerances_type (const ::xercesc::DOMElement&,
                       ::xml_schema::flags = 0,
                       ::xml_schema::type* = 0);

  ksp_tolerances_type (const ksp_tolerances_type&,
                       ::xml_schema::flags = 0,
                       ::xml_schema::type* = 0);

  virtual ksp_tolerances_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::optional< KSPRelative::type > _xsd_KSPRelative_;
  ::xsd::cxx::tree::optional< KSPAbsolute::type > _xsd_KSPAbsolute_;
};

class ksp_solver_type: public ::xml_schema::string
{
  public:
  enum _xsd_ksp_solver_type
  {
    cg,
    symmlq,
    gmres
  };

  ksp_solver_type (_xsd_ksp_solver_type);

  ksp_solver_type (const ::xml_schema::string&);

  ksp_solver_type (const ::xercesc::DOMElement&,
                   ::xml_schema::flags = 0,
                   ::xml_schema::type* = 0);

  ksp_solver_type (const ::xercesc::DOMAttr&,
                   ::xml_schema::flags = 0,
                   ::xml_schema::type* = 0);

  ksp_solver_type (const ::std::basic_string< char >&,
                   const ::xercesc::DOMElement*,
                   ::xml_schema::flags = 0,
                   ::xml_schema::type* = 0);

  ksp_solver_type (const ksp_solver_type&,
                   ::xml_schema::flags = 0,
                   ::xml_schema::type* = 0);

  virtual ksp_solver_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  ksp_solver_type&
  operator= (_xsd_ksp_solver_type);

  virtual
  operator _xsd_ksp_solver_type () const
  {
    return _xsd_ksp_solver_type_convert ();
  }

  protected:
  _xsd_ksp_solver_type
  _xsd_ksp_solver_type_convert () const;

  public:
  static const char* const _xsd_ksp_solver_type_literals_[3];
  static const _xsd_ksp_solver_type _xsd_ksp_solver_type_indexes_[3];
};

class ksp_preconditioner_type: public ::xml_schema::string
{
  public:
  enum _xsd_ksp_preconditioner_type
  {
    ilu,
    jacobi,
    bjacobi,
    hypre,
    none
  };

  ksp_preconditioner_type (_xsd_ksp_preconditioner_type);

  ksp_preconditioner_type (const ::xml_schema::string&);

  ksp_preconditioner_type (const ::xercesc::DOMElement&,
                           ::xml_schema::flags = 0,
                           ::xml_schema::type* = 0);

  ksp_preconditioner_type (const ::xercesc::DOMAttr&,
                           ::xml_schema::flags = 0,
                           ::xml_schema::type* = 0);

  ksp_preconditioner_type (const ::std::basic_string< char >&,
                           const ::xercesc::DOMElement*,
                           ::xml_schema::flags = 0,
                           ::xml_schema::type* = 0);

  ksp_preconditioner_type (const ksp_preconditioner_type&,
                           ::xml_schema::flags = 0,
                           ::xml_schema::type* = 0);

  virtual ksp_preconditioner_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  ksp_preconditioner_type&
  operator= (_xsd_ksp_preconditioner_type);

  virtual
  operator _xsd_ksp_preconditioner_type () const
  {
    return _xsd_ksp_preconditioner_type_convert ();
  }

  protected:
  _xsd_ksp_preconditioner_type
  _xsd_ksp_preconditioner_type_convert () const;

  public:
  static const char* const _xsd_ksp_preconditioner_type_literals_[5];
  static const _xsd_ksp_preconditioner_type _xsd_ksp_preconditioner_type_indexes_[5];
};

class simulation_type: public ::xml_schema::type
{
  public:

  struct _xsd_simulation_type
  {
    typedef ::xml_schema::type base_;
  };

  // SpaceDimension
  // 
  public:
  struct SpaceDimension
  {
    typedef ::xml_schema::integer type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const SpaceDimension::container&
  SpaceDimension () const;

  SpaceDimension::container&
  SpaceDimension ();

  void
  SpaceDimension (const SpaceDimension::type&);

  void
  SpaceDimension (const SpaceDimension::container&);

  // SimulationDuration
  // 
  public:
  struct SimulationDuration
  {
    typedef ::time_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const SimulationDuration::container&
  SimulationDuration () const;

  SimulationDuration::container&
  SimulationDuration ();

  void
  SimulationDuration (const SimulationDuration::type&);

  void
  SimulationDuration (const SimulationDuration::container&);

  void
  SimulationDuration (::std::auto_ptr< SimulationDuration::type >);

  // Domain
  // 
  public:
  struct Domain
  {
    typedef ::domain_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const Domain::container&
  Domain () const;

  Domain::container&
  Domain ();

  void
  Domain (const Domain::type&);

  void
  Domain (const Domain::container&);

  void
  Domain (::std::auto_ptr< Domain::type >);

  // Mesh
  // 
  public:
  struct Mesh
  {
    typedef ::mesh_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const Mesh::container&
  Mesh () const;

  Mesh::container&
  Mesh ();

  void
  Mesh (const Mesh::type&);

  void
  Mesh (const Mesh::container&);

  void
  Mesh (::std::auto_ptr< Mesh::type >);

  // IonicModels
  // 
  public:
  struct IonicModels
  {
    typedef ::ionic_models_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const IonicModels::container&
  IonicModels () const;

  IonicModels::container&
  IonicModels ();

  void
  IonicModels (const IonicModels::type&);

  void
  IonicModels (const IonicModels::container&);

  void
  IonicModels (::std::auto_ptr< IonicModels::type >);

  // Stimuli
  // 
  public:
  struct Stimuli
  {
    struct _xsd_Stimuli_
    {
      class Stimuli: public ::xml_schema::type
      {
        public:

        struct _xsd_Stimuli
        {
          typedef ::xml_schema::type base_;
        };

        // Stimulus
        // 
        public:
        struct Stimulus
        {
          typedef ::stimulus_type type;
          typedef ::xsd::cxx::tree::traits< type, char > traits;
          typedef ::xsd::cxx::tree::sequence< type > container;
          typedef container::iterator iterator;
          typedef container::const_iterator const_iterator;
        };

        const Stimulus::container&
        Stimulus () const;

        Stimulus::container&
        Stimulus ();

        void
        Stimulus (const Stimulus::container&);

        // Constructors.
        //
        public:
        Stimuli ();

        Stimuli (const ::xercesc::DOMElement&,
                 ::xml_schema::flags = 0,
                 ::xml_schema::type* = 0);

        Stimuli (const Stimuli&,
                 ::xml_schema::flags = 0,
                 ::xml_schema::type* = 0);

        virtual Stimuli*
        _clone (::xml_schema::flags = 0,
                ::xml_schema::type* = 0) const;

        // Implementation.
        //
        private:
        void
        parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

        ::xsd::cxx::tree::sequence< Stimulus::type > _xsd_Stimulus_;
      };
    };

    typedef _xsd_Stimuli_::Stimuli type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const Stimuli::container&
  Stimuli () const;

  Stimuli::container&
  Stimuli ();

  void
  Stimuli (const Stimuli::type&);

  void
  Stimuli (const Stimuli::container&);

  void
  Stimuli (::std::auto_ptr< Stimuli::type >);

  // CellHeterogeneities
  // 
  public:
  struct CellHeterogeneities
  {
    struct _xsd_CellHeterogeneities_
    {
      class CellHeterogeneities: public ::xml_schema::type
      {
        public:

        struct _xsd_CellHeterogeneities
        {
          typedef ::xml_schema::type base_;
        };

        // CellHeterogeneity
        // 
        public:
        struct CellHeterogeneity
        {
          typedef ::cell_heterogeneity_type type;
          typedef ::xsd::cxx::tree::traits< type, char > traits;
          typedef ::xsd::cxx::tree::sequence< type > container;
          typedef container::iterator iterator;
          typedef container::const_iterator const_iterator;
        };

        const CellHeterogeneity::container&
        CellHeterogeneity () const;

        CellHeterogeneity::container&
        CellHeterogeneity ();

        void
        CellHeterogeneity (const CellHeterogeneity::container&);

        // Constructors.
        //
        public:
        CellHeterogeneities ();

        CellHeterogeneities (const ::xercesc::DOMElement&,
                             ::xml_schema::flags = 0,
                             ::xml_schema::type* = 0);

        CellHeterogeneities (const CellHeterogeneities&,
                             ::xml_schema::flags = 0,
                             ::xml_schema::type* = 0);

        virtual CellHeterogeneities*
        _clone (::xml_schema::flags = 0,
                ::xml_schema::type* = 0) const;

        // Implementation.
        //
        private:
        void
        parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

        ::xsd::cxx::tree::sequence< CellHeterogeneity::type > _xsd_CellHeterogeneity_;
      };
    };

    typedef _xsd_CellHeterogeneities_::CellHeterogeneities type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const CellHeterogeneities::container&
  CellHeterogeneities () const;

  CellHeterogeneities::container&
  CellHeterogeneities ();

  void
  CellHeterogeneities (const CellHeterogeneities::type&);

  void
  CellHeterogeneities (const CellHeterogeneities::container&);

  void
  CellHeterogeneities (::std::auto_ptr< CellHeterogeneities::type >);

  // ConductivityHeterogeneities
  // 
  public:
  struct ConductivityHeterogeneities
  {
    struct _xsd_ConductivityHeterogeneities_
    {
      class ConductivityHeterogeneities: public ::xml_schema::type
      {
        public:

        struct _xsd_ConductivityHeterogeneities
        {
          typedef ::xml_schema::type base_;
        };

        // ConductivityHeterogeneity
        // 
        public:
        struct ConductivityHeterogeneity
        {
          typedef ::conductivity_heterogeneity_type type;
          typedef ::xsd::cxx::tree::traits< type, char > traits;
          typedef ::xsd::cxx::tree::sequence< type > container;
          typedef container::iterator iterator;
          typedef container::const_iterator const_iterator;
        };

        const ConductivityHeterogeneity::container&
        ConductivityHeterogeneity () const;

        ConductivityHeterogeneity::container&
        ConductivityHeterogeneity ();

        void
        ConductivityHeterogeneity (const ConductivityHeterogeneity::container&);

        // Constructors.
        //
        public:
        ConductivityHeterogeneities ();

        ConductivityHeterogeneities (const ::xercesc::DOMElement&,
                                     ::xml_schema::flags = 0,
                                     ::xml_schema::type* = 0);

        ConductivityHeterogeneities (const ConductivityHeterogeneities&,
                                     ::xml_schema::flags = 0,
                                     ::xml_schema::type* = 0);

        virtual ConductivityHeterogeneities*
        _clone (::xml_schema::flags = 0,
                ::xml_schema::type* = 0) const;

        // Implementation.
        //
        private:
        void
        parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

        ::xsd::cxx::tree::sequence< ConductivityHeterogeneity::type > _xsd_ConductivityHeterogeneity_;
      };
    };

    typedef _xsd_ConductivityHeterogeneities_::ConductivityHeterogeneities type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const ConductivityHeterogeneities::container&
  ConductivityHeterogeneities () const;

  ConductivityHeterogeneities::container&
  ConductivityHeterogeneities ();

  void
  ConductivityHeterogeneities (const ConductivityHeterogeneities::type&);

  void
  ConductivityHeterogeneities (const ConductivityHeterogeneities::container&);

  void
  ConductivityHeterogeneities (::std::auto_ptr< ConductivityHeterogeneities::type >);

  // OutputDirectory
  // 
  public:
  struct OutputDirectory
  {
    typedef ::xml_schema::string type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const OutputDirectory::container&
  OutputDirectory () const;

  OutputDirectory::container&
  OutputDirectory ();

  void
  OutputDirectory (const OutputDirectory::type&);

  void
  OutputDirectory (const OutputDirectory::container&);

  void
  OutputDirectory (::std::auto_ptr< OutputDirectory::type >);

  // OutputFilenamePrefix
  // 
  public:
  struct OutputFilenamePrefix
  {
    typedef ::xml_schema::string type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const OutputFilenamePrefix::container&
  OutputFilenamePrefix () const;

  OutputFilenamePrefix::container&
  OutputFilenamePrefix ();

  void
  OutputFilenamePrefix (const OutputFilenamePrefix::type&);

  void
  OutputFilenamePrefix (const OutputFilenamePrefix::container&);

  void
  OutputFilenamePrefix (::std::auto_ptr< OutputFilenamePrefix::type >);

  // Constructors.
  //
  public:
  simulation_type ();

  simulation_type (const ::xercesc::DOMElement&,
                   ::xml_schema::flags = 0,
                   ::xml_schema::type* = 0);

  simulation_type (const simulation_type&,
                   ::xml_schema::flags = 0,
                   ::xml_schema::type* = 0);

  virtual simulation_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::optional< SpaceDimension::type > _xsd_SpaceDimension_;
  ::xsd::cxx::tree::optional< SimulationDuration::type > _xsd_SimulationDuration_;
  ::xsd::cxx::tree::optional< Domain::type > _xsd_Domain_;
  ::xsd::cxx::tree::optional< Mesh::type > _xsd_Mesh_;
  ::xsd::cxx::tree::optional< IonicModels::type > _xsd_IonicModels_;
  ::xsd::cxx::tree::optional< Stimuli::type > _xsd_Stimuli_;
  ::xsd::cxx::tree::optional< CellHeterogeneities::type > _xsd_CellHeterogeneities_;
  ::xsd::cxx::tree::optional< ConductivityHeterogeneities::type > _xsd_ConductivityHeterogeneities_;
  ::xsd::cxx::tree::optional< OutputDirectory::type > _xsd_OutputDirectory_;
  ::xsd::cxx::tree::optional< OutputFilenamePrefix::type > _xsd_OutputFilenamePrefix_;
};

class physiological_type: public ::xml_schema::type
{
  public:

  struct _xsd_physiological_type
  {
    typedef ::xml_schema::type base_;
  };

  // IntracellularConductivities
  // 
  public:
  struct IntracellularConductivities
  {
    typedef ::conductivities_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const IntracellularConductivities::container&
  IntracellularConductivities () const;

  IntracellularConductivities::container&
  IntracellularConductivities ();

  void
  IntracellularConductivities (const IntracellularConductivities::type&);

  void
  IntracellularConductivities (const IntracellularConductivities::container&);

  void
  IntracellularConductivities (::std::auto_ptr< IntracellularConductivities::type >);

  // ExtracellularConductivities
  // 
  public:
  struct ExtracellularConductivities
  {
    typedef ::conductivities_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const ExtracellularConductivities::container&
  ExtracellularConductivities () const;

  ExtracellularConductivities::container&
  ExtracellularConductivities ();

  void
  ExtracellularConductivities (const ExtracellularConductivities::type&);

  void
  ExtracellularConductivities (const ExtracellularConductivities::container&);

  void
  ExtracellularConductivities (::std::auto_ptr< ExtracellularConductivities::type >);

  // BathConductivity
  // 
  public:
  struct BathConductivity
  {
    typedef ::conductivity_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const BathConductivity::container&
  BathConductivity () const;

  BathConductivity::container&
  BathConductivity ();

  void
  BathConductivity (const BathConductivity::type&);

  void
  BathConductivity (const BathConductivity::container&);

  void
  BathConductivity (::std::auto_ptr< BathConductivity::type >);

  // SurfaceAreaToVolumeRatio
  // 
  public:
  struct SurfaceAreaToVolumeRatio
  {
    typedef ::inverse_length_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const SurfaceAreaToVolumeRatio::container&
  SurfaceAreaToVolumeRatio () const;

  SurfaceAreaToVolumeRatio::container&
  SurfaceAreaToVolumeRatio ();

  void
  SurfaceAreaToVolumeRatio (const SurfaceAreaToVolumeRatio::type&);

  void
  SurfaceAreaToVolumeRatio (const SurfaceAreaToVolumeRatio::container&);

  void
  SurfaceAreaToVolumeRatio (::std::auto_ptr< SurfaceAreaToVolumeRatio::type >);

  // Capacitance
  // 
  public:
  struct Capacitance
  {
    typedef ::capacitance_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const Capacitance::container&
  Capacitance () const;

  Capacitance::container&
  Capacitance ();

  void
  Capacitance (const Capacitance::type&);

  void
  Capacitance (const Capacitance::container&);

  void
  Capacitance (::std::auto_ptr< Capacitance::type >);

  // Constructors.
  //
  public:
  physiological_type ();

  physiological_type (const ::xercesc::DOMElement&,
                      ::xml_schema::flags = 0,
                      ::xml_schema::type* = 0);

  physiological_type (const physiological_type&,
                      ::xml_schema::flags = 0,
                      ::xml_schema::type* = 0);

  virtual physiological_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::optional< IntracellularConductivities::type > _xsd_IntracellularConductivities_;
  ::xsd::cxx::tree::optional< ExtracellularConductivities::type > _xsd_ExtracellularConductivities_;
  ::xsd::cxx::tree::optional< BathConductivity::type > _xsd_BathConductivity_;
  ::xsd::cxx::tree::optional< SurfaceAreaToVolumeRatio::type > _xsd_SurfaceAreaToVolumeRatio_;
  ::xsd::cxx::tree::optional< Capacitance::type > _xsd_Capacitance_;
};

class numerical_type: public ::xml_schema::type
{
  public:

  struct _xsd_numerical_type
  {
    typedef ::xml_schema::type base_;
  };

  // TimeSteps
  // 
  public:
  struct TimeSteps
  {
    typedef ::time_steps_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const TimeSteps::container&
  TimeSteps () const;

  TimeSteps::container&
  TimeSteps ();

  void
  TimeSteps (const TimeSteps::type&);

  void
  TimeSteps (const TimeSteps::container&);

  void
  TimeSteps (::std::auto_ptr< TimeSteps::type >);

  // KSPTolerances
  // 
  public:
  struct KSPTolerances
  {
    typedef ::ksp_tolerances_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const KSPTolerances::container&
  KSPTolerances () const;

  KSPTolerances::container&
  KSPTolerances ();

  void
  KSPTolerances (const KSPTolerances::type&);

  void
  KSPTolerances (const KSPTolerances::container&);

  void
  KSPTolerances (::std::auto_ptr< KSPTolerances::type >);

  // KSPSolver
  // 
  public:
  struct KSPSolver
  {
    typedef ::ksp_solver_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const KSPSolver::container&
  KSPSolver () const;

  KSPSolver::container&
  KSPSolver ();

  void
  KSPSolver (const KSPSolver::type&);

  void
  KSPSolver (const KSPSolver::container&);

  void
  KSPSolver (::std::auto_ptr< KSPSolver::type >);

  // KSPPreconditioner
  // 
  public:
  struct KSPPreconditioner
  {
    typedef ::ksp_preconditioner_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
    typedef ::xsd::cxx::tree::optional< type > container;
  };

  const KSPPreconditioner::container&
  KSPPreconditioner () const;

  KSPPreconditioner::container&
  KSPPreconditioner ();

  void
  KSPPreconditioner (const KSPPreconditioner::type&);

  void
  KSPPreconditioner (const KSPPreconditioner::container&);

  void
  KSPPreconditioner (::std::auto_ptr< KSPPreconditioner::type >);

  // Constructors.
  //
  public:
  numerical_type ();

  numerical_type (const ::xercesc::DOMElement&,
                  ::xml_schema::flags = 0,
                  ::xml_schema::type* = 0);

  numerical_type (const numerical_type&,
                  ::xml_schema::flags = 0,
                  ::xml_schema::type* = 0);

  virtual numerical_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::optional< TimeSteps::type > _xsd_TimeSteps_;
  ::xsd::cxx::tree::optional< KSPTolerances::type > _xsd_KSPTolerances_;
  ::xsd::cxx::tree::optional< KSPSolver::type > _xsd_KSPSolver_;
  ::xsd::cxx::tree::optional< KSPPreconditioner::type > _xsd_KSPPreconditioner_;
};

class chaste_parameters_type: public ::xml_schema::type
{
  public:

  struct _xsd_chaste_parameters_type
  {
    typedef ::xml_schema::type base_;
  };

  // Simulation
  // 
  public:
  struct Simulation
  {
    typedef ::simulation_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const Simulation::type&
  Simulation () const;

  Simulation::type&
  Simulation ();

  void
  Simulation (const Simulation::type&);

  void
  Simulation (::std::auto_ptr< Simulation::type >);

  // Physiological
  // 
  public:
  struct Physiological
  {
    typedef ::physiological_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const Physiological::type&
  Physiological () const;

  Physiological::type&
  Physiological ();

  void
  Physiological (const Physiological::type&);

  void
  Physiological (::std::auto_ptr< Physiological::type >);

  // Numerical
  // 
  public:
  struct Numerical
  {
    typedef ::numerical_type type;
    typedef ::xsd::cxx::tree::traits< type, char > traits;
  };

  const Numerical::type&
  Numerical () const;

  Numerical::type&
  Numerical ();

  void
  Numerical (const Numerical::type&);

  void
  Numerical (::std::auto_ptr< Numerical::type >);

  // Constructors.
  //
  public:
  chaste_parameters_type (const Simulation::type&,
                          const Physiological::type&,
                          const Numerical::type&);

  chaste_parameters_type (const ::xercesc::DOMElement&,
                          ::xml_schema::flags = 0,
                          ::xml_schema::type* = 0);

  chaste_parameters_type (const chaste_parameters_type&,
                          ::xml_schema::flags = 0,
                          ::xml_schema::type* = 0);

  virtual chaste_parameters_type*
  _clone (::xml_schema::flags = 0,
          ::xml_schema::type* = 0) const;

  // Implementation.
  //
  private:
  void
  parse (const ::xercesc::DOMElement&, ::xml_schema::flags);

  ::xsd::cxx::tree::one< Simulation::type > _xsd_Simulation_;
  ::xsd::cxx::tree::one< Physiological::type > _xsd_Physiological_;
  ::xsd::cxx::tree::one< Numerical::type > _xsd_Numerical_;
};

#include <iosfwd>

#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMInputSource.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>

// Read from a URI or a local file.
//

::std::auto_ptr< ::chaste_parameters_type >
ChasteParameters (const ::std::basic_string< char >&,
                  ::xml_schema::flags = 0,
                  const ::xsd::cxx::tree::properties< char >& = ::xsd::cxx::tree::properties< char > ());

::std::auto_ptr< ::chaste_parameters_type >
ChasteParameters (const ::std::basic_string< char >&,
                  ::xsd::cxx::xml::error_handler< char >&,
                  ::xml_schema::flags = 0,
                  const ::xsd::cxx::tree::properties< char >& = ::xsd::cxx::tree::properties< char > ());

::std::auto_ptr< ::chaste_parameters_type >
ChasteParameters (const ::std::basic_string< char >&,
                  ::xercesc::DOMErrorHandler&,
                  ::xml_schema::flags = 0,
                  const ::xsd::cxx::tree::properties< char >& = ::xsd::cxx::tree::properties< char > ());


// Read from std::istream.
//

::std::auto_ptr< ::chaste_parameters_type >
ChasteParameters (::std::istream&,
                  ::xml_schema::flags = 0,
                  const ::xsd::cxx::tree::properties< char >& = ::xsd::cxx::tree::properties< char > ());

::std::auto_ptr< ::chaste_parameters_type >
ChasteParameters (::std::istream&,
                  ::xsd::cxx::xml::error_handler< char >&,
                  ::xml_schema::flags = 0,
                  const ::xsd::cxx::tree::properties< char >& = ::xsd::cxx::tree::properties< char > ());

::std::auto_ptr< ::chaste_parameters_type >
ChasteParameters (::std::istream&,
                  ::xercesc::DOMErrorHandler&,
                  ::xml_schema::flags = 0,
                  const ::xsd::cxx::tree::properties< char >& = ::xsd::cxx::tree::properties< char > ());


::std::auto_ptr< ::chaste_parameters_type >
ChasteParameters (::std::istream&,
                  const ::std::basic_string< char >& id,
                  ::xml_schema::flags = 0,
                  const ::xsd::cxx::tree::properties< char >& = ::xsd::cxx::tree::properties< char > ());

::std::auto_ptr< ::chaste_parameters_type >
ChasteParameters (::std::istream&,
                  const ::std::basic_string< char >& id,
                  ::xsd::cxx::xml::error_handler< char >&,
                  ::xml_schema::flags = 0,
                  const ::xsd::cxx::tree::properties< char >& = ::xsd::cxx::tree::properties< char > ());

::std::auto_ptr< ::chaste_parameters_type >
ChasteParameters (::std::istream&,
                  const ::std::basic_string< char >& id,
                  ::xercesc::DOMErrorHandler&,
                  ::xml_schema::flags = 0,
                  const ::xsd::cxx::tree::properties< char >& = ::xsd::cxx::tree::properties< char > ());


// Read from InputSource.
//

::std::auto_ptr< ::chaste_parameters_type >
ChasteParameters (const ::xercesc::DOMInputSource&,
                  ::xml_schema::flags = 0,
                  const ::xsd::cxx::tree::properties< char >& = ::xsd::cxx::tree::properties< char > ());

::std::auto_ptr< ::chaste_parameters_type >
ChasteParameters (const ::xercesc::DOMInputSource&,
                  ::xsd::cxx::xml::error_handler< char >&,
                  ::xml_schema::flags = 0,
                  const ::xsd::cxx::tree::properties< char >& = ::xsd::cxx::tree::properties< char > ());

::std::auto_ptr< ::chaste_parameters_type >
ChasteParameters (const ::xercesc::DOMInputSource&,
                  ::xercesc::DOMErrorHandler&,
                  ::xml_schema::flags = 0,
                  const ::xsd::cxx::tree::properties< char >& = ::xsd::cxx::tree::properties< char > ());


// Read from DOM.
//

::std::auto_ptr< ::chaste_parameters_type >
ChasteParameters (const ::xercesc::DOMDocument&,
                  ::xml_schema::flags = 0,
                  const ::xsd::cxx::tree::properties< char >& = ::xsd::cxx::tree::properties< char > ());


#include <iosfwd> // std::ostream&

#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
#include <xercesc/framework/XMLFormatter.hpp>

#include <xsd/cxx/xml/dom/auto-ptr.hxx>

void
operator<< (::xercesc::DOMElement&,
            const time_type&);

void
operator<< (::xercesc::DOMElement&,
            const dimensionless_type&);

void
operator<< (::xercesc::DOMElement&,
            const conductivity_type&);

void
operator<< (::xercesc::DOMElement&,
            const stimulus_strength_type&);

void
operator<< (::xercesc::DOMElement&,
            const inverse_length_type&);

void
operator<< (::xercesc::DOMElement&,
            const capacitance_type&);

void
operator<< (::xercesc::DOMElement&,
            const location_type&);

void
operator<< (::xercesc::DOMElement&,
            domain_type);

void
operator<< (::xercesc::DOMAttr&,
            domain_type);

void
operator<< (::xsd::cxx::tree::list_stream< char >&,
            domain_type);

void
operator<< (::xercesc::DOMElement&,
            ionic_models_available_type);

void
operator<< (::xercesc::DOMAttr&,
            ionic_models_available_type);

void
operator<< (::xsd::cxx::tree::list_stream< char >&,
            ionic_models_available_type);

void
operator<< (::xercesc::DOMElement&,
            const ionic_model_region_type&);

void
operator<< (::xercesc::DOMElement&,
            const ionic_models_type&);

void
operator<< (::xercesc::DOMElement&,
            media_type);

void
operator<< (::xercesc::DOMAttr&,
            media_type);

void
operator<< (::xsd::cxx::tree::list_stream< char >&,
            media_type);

void
operator<< (::xercesc::DOMElement&,
            const point_type&);

void
operator<< (::xercesc::DOMElement&,
            const box_type&);

void
operator<< (::xercesc::DOMElement&,
            const stimulus_type&);

void
operator<< (::xercesc::DOMElement&,
            const cell_heterogeneity_type&);

void
operator<< (::xercesc::DOMElement&,
            const conductivity_heterogeneity_type&);

void
operator<< (::xercesc::DOMElement&,
            const slab_type&);

void
operator<< (::xercesc::DOMElement&,
            const sheet_type&);

void
operator<< (::xercesc::DOMElement&,
            const fibre_type&);

void
operator<< (::xercesc::DOMElement&,
            const load_mesh_type&);

void
operator<< (::xercesc::DOMElement&,
            const mesh_type&);

void
operator<< (::xercesc::DOMElement&,
            const conductivities_type&);

void
operator<< (::xercesc::DOMElement&,
            const time_steps_type&);

void
operator<< (::xercesc::DOMElement&,
            ksp_use_type);

void
operator<< (::xercesc::DOMAttr&,
            ksp_use_type);

void
operator<< (::xsd::cxx::tree::list_stream< char >&,
            ksp_use_type);

void
operator<< (::xercesc::DOMElement&,
            const ksp_tolerances_type&);

void
operator<< (::xercesc::DOMElement&,
            ksp_solver_type);

void
operator<< (::xercesc::DOMAttr&,
            ksp_solver_type);

void
operator<< (::xsd::cxx::tree::list_stream< char >&,
            ksp_solver_type);

void
operator<< (::xercesc::DOMElement&,
            ksp_preconditioner_type);

void
operator<< (::xercesc::DOMAttr&,
            ksp_preconditioner_type);

void
operator<< (::xsd::cxx::tree::list_stream< char >&,
            ksp_preconditioner_type);

void
operator<< (::xercesc::DOMElement&,
            const simulation_type::Stimuli::type&);

void
operator<< (::xercesc::DOMElement&,
            const simulation_type::CellHeterogeneities::type&);

void
operator<< (::xercesc::DOMElement&,
            const simulation_type::ConductivityHeterogeneities::type&);

void
operator<< (::xercesc::DOMElement&,
            const simulation_type&);

void
operator<< (::xercesc::DOMElement&,
            const physiological_type&);

void
operator<< (::xercesc::DOMElement&,
            const numerical_type&);

void
operator<< (::xercesc::DOMElement&,
            const chaste_parameters_type&);

// Serialize to an existing DOM instance.
//
void
ChasteParameters (::xercesc::DOMDocument&,
                  const ::chaste_parameters_type&,
                  ::xml_schema::flags = 0);


// Serialize to a new DOM instance.
//
::xsd::cxx::xml::dom::auto_ptr< ::xercesc::DOMDocument >
ChasteParameters (const ::chaste_parameters_type&, 
                  const ::xsd::cxx::xml::dom::namespace_infomap< char >&,
                  ::xml_schema::flags = 0);


// Serialize to XMLFormatTarget.
//
void
ChasteParameters (::xercesc::XMLFormatTarget&,
                  const ::chaste_parameters_type&, 
                  const ::xsd::cxx::xml::dom::namespace_infomap< char >&,
                  const ::std::basic_string< char >& = "UTF-8",
                  ::xml_schema::flags = 0);


void
ChasteParameters (::xercesc::XMLFormatTarget&,
                  const ::chaste_parameters_type&, 
                  const ::xsd::cxx::xml::dom::namespace_infomap< char >&,
                  ::xsd::cxx::xml::error_handler< char >&,
                  const ::std::basic_string< char >& = "UTF-8",
                  ::xml_schema::flags = 0);

void
ChasteParameters (::xercesc::XMLFormatTarget&,
                  const ::chaste_parameters_type&, 
                  const ::xsd::cxx::xml::dom::namespace_infomap< char >&,
                  ::xercesc::DOMErrorHandler&,
                  const ::std::basic_string< char >& = "UTF-8",
                  ::xml_schema::flags = 0);


// Serialize to std::ostream.
//
void
ChasteParameters (::std::ostream&,
                  const ::chaste_parameters_type&, 
                  const ::xsd::cxx::xml::dom::namespace_infomap< char >&,
                  const ::std::basic_string< char >& = "UTF-8",
                  ::xml_schema::flags = 0);


void
ChasteParameters (::std::ostream&,
                  const ::chaste_parameters_type&, 
                  const ::xsd::cxx::xml::dom::namespace_infomap< char >&,
                  ::xsd::cxx::xml::error_handler< char >&,
                  const ::std::basic_string< char >& = "UTF-8",
                  ::xml_schema::flags = 0);

void
ChasteParameters (::std::ostream&,
                  const ::chaste_parameters_type&, 
                  const ::xsd::cxx::xml::dom::namespace_infomap< char >&,
                  ::xercesc::DOMErrorHandler&,
                  const ::std::basic_string< char >& = "UTF-8",
                  ::xml_schema::flags = 0);


#include <xsd/cxx/post.hxx>

// Begin epilogue.
//
#undef COVERAGE_IGNORE
//
// End epilogue.

#endif // CHASTE_PARAMETERS_HPP

---