//+
// C++ classes definitions for Tao / C++ structure interface.
//
// This file is generated as part of the Tao/C++ interface code generation.
// The code generation files can be found in cpp_tao_interface.
//
// DO NOT EDIT THIS FILE DIRECTLY! 
//-

#ifndef CPP_TAO_CLASSES

#include <string>
#include <valarray>
#include <complex>
#include "cpp_bmad_classes.h"

class CPP_qp_rect;
typedef valarray<CPP_qp_rect>          CPP_qp_rect_ARRAY;
typedef valarray<CPP_qp_rect_ARRAY>    CPP_qp_rect_MATRIX;
typedef valarray<CPP_qp_rect_MATRIX>   CPP_qp_rect_TENSOR;

class CPP_qp_line;
typedef valarray<CPP_qp_line>          CPP_qp_line_ARRAY;
typedef valarray<CPP_qp_line_ARRAY>    CPP_qp_line_MATRIX;
typedef valarray<CPP_qp_line_MATRIX>   CPP_qp_line_TENSOR;

class CPP_qp_symbol;
typedef valarray<CPP_qp_symbol>          CPP_qp_symbol_ARRAY;
typedef valarray<CPP_qp_symbol_ARRAY>    CPP_qp_symbol_MATRIX;
typedef valarray<CPP_qp_symbol_MATRIX>   CPP_qp_symbol_TENSOR;

class CPP_qp_point;
typedef valarray<CPP_qp_point>          CPP_qp_point_ARRAY;
typedef valarray<CPP_qp_point_ARRAY>    CPP_qp_point_MATRIX;
typedef valarray<CPP_qp_point_MATRIX>   CPP_qp_point_TENSOR;

class CPP_qp_axis;
typedef valarray<CPP_qp_axis>          CPP_qp_axis_ARRAY;
typedef valarray<CPP_qp_axis_ARRAY>    CPP_qp_axis_MATRIX;
typedef valarray<CPP_qp_axis_MATRIX>   CPP_qp_axis_TENSOR;

class CPP_tao_cmd_history;
typedef valarray<CPP_tao_cmd_history>          CPP_tao_cmd_history_ARRAY;
typedef valarray<CPP_tao_cmd_history_ARRAY>    CPP_tao_cmd_history_MATRIX;
typedef valarray<CPP_tao_cmd_history_MATRIX>   CPP_tao_cmd_history_TENSOR;

class CPP_tao_real_pointer;
typedef valarray<CPP_tao_real_pointer>          CPP_tao_real_pointer_ARRAY;
typedef valarray<CPP_tao_real_pointer_ARRAY>    CPP_tao_real_pointer_MATRIX;
typedef valarray<CPP_tao_real_pointer_MATRIX>   CPP_tao_real_pointer_TENSOR;

class CPP_tao_logical_array;
typedef valarray<CPP_tao_logical_array>          CPP_tao_logical_array_ARRAY;
typedef valarray<CPP_tao_logical_array_ARRAY>    CPP_tao_logical_array_MATRIX;
typedef valarray<CPP_tao_logical_array_MATRIX>   CPP_tao_logical_array_TENSOR;

class CPP_tao_integer_array;
typedef valarray<CPP_tao_integer_array>          CPP_tao_integer_array_ARRAY;
typedef valarray<CPP_tao_integer_array_ARRAY>    CPP_tao_integer_array_MATRIX;
typedef valarray<CPP_tao_integer_array_MATRIX>   CPP_tao_integer_array_TENSOR;

class CPP_tao_expression_info;
typedef valarray<CPP_tao_expression_info>          CPP_tao_expression_info_ARRAY;
typedef valarray<CPP_tao_expression_info_ARRAY>    CPP_tao_expression_info_MATRIX;
typedef valarray<CPP_tao_expression_info_MATRIX>   CPP_tao_expression_info_TENSOR;

class CPP_tao_eval_stack1;
typedef valarray<CPP_tao_eval_stack1>          CPP_tao_eval_stack1_ARRAY;
typedef valarray<CPP_tao_eval_stack1_ARRAY>    CPP_tao_eval_stack1_MATRIX;
typedef valarray<CPP_tao_eval_stack1_MATRIX>   CPP_tao_eval_stack1_TENSOR;

class CPP_tao_ele_shape;
typedef valarray<CPP_tao_ele_shape>          CPP_tao_ele_shape_ARRAY;
typedef valarray<CPP_tao_ele_shape_ARRAY>    CPP_tao_ele_shape_MATRIX;
typedef valarray<CPP_tao_ele_shape_MATRIX>   CPP_tao_ele_shape_TENSOR;

class CPP_tao_pattern_point;
typedef valarray<CPP_tao_pattern_point>          CPP_tao_pattern_point_ARRAY;
typedef valarray<CPP_tao_pattern_point_ARRAY>    CPP_tao_pattern_point_MATRIX;
typedef valarray<CPP_tao_pattern_point_MATRIX>   CPP_tao_pattern_point_TENSOR;

class CPP_tao_pattern_curve;
typedef valarray<CPP_tao_pattern_curve>          CPP_tao_pattern_curve_ARRAY;
typedef valarray<CPP_tao_pattern_curve_ARRAY>    CPP_tao_pattern_curve_MATRIX;
typedef valarray<CPP_tao_pattern_curve_MATRIX>   CPP_tao_pattern_curve_TENSOR;

class CPP_tao_shape_pattern;
typedef valarray<CPP_tao_shape_pattern>          CPP_tao_shape_pattern_ARRAY;
typedef valarray<CPP_tao_shape_pattern_ARRAY>    CPP_tao_shape_pattern_MATRIX;
typedef valarray<CPP_tao_shape_pattern_MATRIX>   CPP_tao_shape_pattern_TENSOR;

class CPP_tao_drawing;
typedef valarray<CPP_tao_drawing>          CPP_tao_drawing_ARRAY;
typedef valarray<CPP_tao_drawing_ARRAY>    CPP_tao_drawing_MATRIX;
typedef valarray<CPP_tao_drawing_MATRIX>   CPP_tao_drawing_TENSOR;

class CPP_tao_wave_kick_pt;
typedef valarray<CPP_tao_wave_kick_pt>          CPP_tao_wave_kick_pt_ARRAY;
typedef valarray<CPP_tao_wave_kick_pt_ARRAY>    CPP_tao_wave_kick_pt_MATRIX;
typedef valarray<CPP_tao_wave_kick_pt_MATRIX>   CPP_tao_wave_kick_pt_TENSOR;

class CPP_tao_wave;
typedef valarray<CPP_tao_wave>          CPP_tao_wave_ARRAY;
typedef valarray<CPP_tao_wave_ARRAY>    CPP_tao_wave_MATRIX;
typedef valarray<CPP_tao_wave_MATRIX>   CPP_tao_wave_TENSOR;

class CPP_tao_title;
typedef valarray<CPP_tao_title>          CPP_tao_title_ARRAY;
typedef valarray<CPP_tao_title_ARRAY>    CPP_tao_title_MATRIX;
typedef valarray<CPP_tao_title_MATRIX>   CPP_tao_title_TENSOR;

class CPP_tao_data_var_component;
typedef valarray<CPP_tao_data_var_component>          CPP_tao_data_var_component_ARRAY;
typedef valarray<CPP_tao_data_var_component_ARRAY>    CPP_tao_data_var_component_MATRIX;
typedef valarray<CPP_tao_data_var_component_MATRIX>   CPP_tao_data_var_component_TENSOR;

class CPP_tao_histogram;
typedef valarray<CPP_tao_histogram>          CPP_tao_histogram_ARRAY;
typedef valarray<CPP_tao_histogram_ARRAY>    CPP_tao_histogram_MATRIX;
typedef valarray<CPP_tao_histogram_MATRIX>   CPP_tao_histogram_TENSOR;

class CPP_tao_curve;
typedef valarray<CPP_tao_curve>          CPP_tao_curve_ARRAY;
typedef valarray<CPP_tao_curve_ARRAY>    CPP_tao_curve_MATRIX;
typedef valarray<CPP_tao_curve_MATRIX>   CPP_tao_curve_TENSOR;

class CPP_tao_graph;
typedef valarray<CPP_tao_graph>          CPP_tao_graph_ARRAY;
typedef valarray<CPP_tao_graph_ARRAY>    CPP_tao_graph_MATRIX;
typedef valarray<CPP_tao_graph_MATRIX>   CPP_tao_graph_TENSOR;

class CPP_tao_plot;
typedef valarray<CPP_tao_plot>          CPP_tao_plot_ARRAY;
typedef valarray<CPP_tao_plot_ARRAY>    CPP_tao_plot_MATRIX;
typedef valarray<CPP_tao_plot_MATRIX>   CPP_tao_plot_TENSOR;

class CPP_tao_plot_region;
typedef valarray<CPP_tao_plot_region>          CPP_tao_plot_region_ARRAY;
typedef valarray<CPP_tao_plot_region_ARRAY>    CPP_tao_plot_region_MATRIX;
typedef valarray<CPP_tao_plot_region_MATRIX>   CPP_tao_plot_region_TENSOR;

class CPP_tao_plot_page;
typedef valarray<CPP_tao_plot_page>          CPP_tao_plot_page_ARRAY;
typedef valarray<CPP_tao_plot_page_ARRAY>    CPP_tao_plot_page_MATRIX;
typedef valarray<CPP_tao_plot_page_MATRIX>   CPP_tao_plot_page_TENSOR;

class CPP_tao_plot_array;
typedef valarray<CPP_tao_plot_array>          CPP_tao_plot_array_ARRAY;
typedef valarray<CPP_tao_plot_array_ARRAY>    CPP_tao_plot_array_MATRIX;
typedef valarray<CPP_tao_plot_array_MATRIX>   CPP_tao_plot_array_TENSOR;

class CPP_tao_graph_array;
typedef valarray<CPP_tao_graph_array>          CPP_tao_graph_array_ARRAY;
typedef valarray<CPP_tao_graph_array_ARRAY>    CPP_tao_graph_array_MATRIX;
typedef valarray<CPP_tao_graph_array_MATRIX>   CPP_tao_graph_array_TENSOR;

class CPP_tao_curve_array;
typedef valarray<CPP_tao_curve_array>          CPP_tao_curve_array_ARRAY;
typedef valarray<CPP_tao_curve_array_ARRAY>    CPP_tao_curve_array_MATRIX;
typedef valarray<CPP_tao_curve_array_MATRIX>   CPP_tao_curve_array_TENSOR;

class CPP_tao_data;
typedef valarray<CPP_tao_data>          CPP_tao_data_ARRAY;
typedef valarray<CPP_tao_data_ARRAY>    CPP_tao_data_MATRIX;
typedef valarray<CPP_tao_data_MATRIX>   CPP_tao_data_TENSOR;

class CPP_tao_d1_data;
typedef valarray<CPP_tao_d1_data>          CPP_tao_d1_data_ARRAY;
typedef valarray<CPP_tao_d1_data_ARRAY>    CPP_tao_d1_data_MATRIX;
typedef valarray<CPP_tao_d1_data_MATRIX>   CPP_tao_d1_data_TENSOR;

class CPP_tao_d2_data;
typedef valarray<CPP_tao_d2_data>          CPP_tao_d2_data_ARRAY;
typedef valarray<CPP_tao_d2_data_ARRAY>    CPP_tao_d2_data_MATRIX;
typedef valarray<CPP_tao_d2_data_MATRIX>   CPP_tao_d2_data_TENSOR;

class CPP_tao_data_array;
typedef valarray<CPP_tao_data_array>          CPP_tao_data_array_ARRAY;
typedef valarray<CPP_tao_data_array_ARRAY>    CPP_tao_data_array_MATRIX;
typedef valarray<CPP_tao_data_array_MATRIX>   CPP_tao_data_array_TENSOR;

class CPP_tao_d1_data_array;
typedef valarray<CPP_tao_d1_data_array>          CPP_tao_d1_data_array_ARRAY;
typedef valarray<CPP_tao_d1_data_array_ARRAY>    CPP_tao_d1_data_array_MATRIX;
typedef valarray<CPP_tao_d1_data_array_MATRIX>   CPP_tao_d1_data_array_TENSOR;

class CPP_tao_d2_data_array;
typedef valarray<CPP_tao_d2_data_array>          CPP_tao_d2_data_array_ARRAY;
typedef valarray<CPP_tao_d2_data_array_ARRAY>    CPP_tao_d2_data_array_MATRIX;
typedef valarray<CPP_tao_d2_data_array_MATRIX>   CPP_tao_d2_data_array_TENSOR;

class CPP_tao_var_slave;
typedef valarray<CPP_tao_var_slave>          CPP_tao_var_slave_ARRAY;
typedef valarray<CPP_tao_var_slave_ARRAY>    CPP_tao_var_slave_MATRIX;
typedef valarray<CPP_tao_var_slave_MATRIX>   CPP_tao_var_slave_TENSOR;

class CPP_tao_var;
typedef valarray<CPP_tao_var>          CPP_tao_var_ARRAY;
typedef valarray<CPP_tao_var_ARRAY>    CPP_tao_var_MATRIX;
typedef valarray<CPP_tao_var_MATRIX>   CPP_tao_var_TENSOR;

class CPP_tao_v1_var;
typedef valarray<CPP_tao_v1_var>          CPP_tao_v1_var_ARRAY;
typedef valarray<CPP_tao_v1_var_ARRAY>    CPP_tao_v1_var_MATRIX;
typedef valarray<CPP_tao_v1_var_MATRIX>   CPP_tao_v1_var_TENSOR;

class CPP_tao_var_array;
typedef valarray<CPP_tao_var_array>          CPP_tao_var_array_ARRAY;
typedef valarray<CPP_tao_var_array_ARRAY>    CPP_tao_var_array_MATRIX;
typedef valarray<CPP_tao_var_array_MATRIX>   CPP_tao_var_array_TENSOR;

class CPP_tao_v1_var_array;
typedef valarray<CPP_tao_v1_var_array>          CPP_tao_v1_var_array_ARRAY;
typedef valarray<CPP_tao_v1_var_array_ARRAY>    CPP_tao_v1_var_array_MATRIX;
typedef valarray<CPP_tao_v1_var_array_MATRIX>   CPP_tao_v1_var_array_TENSOR;

class CPP_tao_building_wall_point;
typedef valarray<CPP_tao_building_wall_point>          CPP_tao_building_wall_point_ARRAY;
typedef valarray<CPP_tao_building_wall_point_ARRAY>    CPP_tao_building_wall_point_MATRIX;
typedef valarray<CPP_tao_building_wall_point_MATRIX>   CPP_tao_building_wall_point_TENSOR;

class CPP_tao_building_wall_section;
typedef valarray<CPP_tao_building_wall_section>          CPP_tao_building_wall_section_ARRAY;
typedef valarray<CPP_tao_building_wall_section_ARRAY>    CPP_tao_building_wall_section_MATRIX;
typedef valarray<CPP_tao_building_wall_section_MATRIX>   CPP_tao_building_wall_section_TENSOR;

class CPP_tao_building_wall;
typedef valarray<CPP_tao_building_wall>          CPP_tao_building_wall_ARRAY;
typedef valarray<CPP_tao_building_wall_ARRAY>    CPP_tao_building_wall_MATRIX;
typedef valarray<CPP_tao_building_wall_MATRIX>   CPP_tao_building_wall_TENSOR;

class CPP_tao_global;
typedef valarray<CPP_tao_global>          CPP_tao_global_ARRAY;
typedef valarray<CPP_tao_global_ARRAY>    CPP_tao_global_MATRIX;
typedef valarray<CPP_tao_global_MATRIX>   CPP_tao_global_TENSOR;

class CPP_tao_alias;
typedef valarray<CPP_tao_alias>          CPP_tao_alias_ARRAY;
typedef valarray<CPP_tao_alias_ARRAY>    CPP_tao_alias_MATRIX;
typedef valarray<CPP_tao_alias_MATRIX>   CPP_tao_alias_TENSOR;

class CPP_tao_command_file;
typedef valarray<CPP_tao_command_file>          CPP_tao_command_file_ARRAY;
typedef valarray<CPP_tao_command_file_ARRAY>    CPP_tao_command_file_MATRIX;
typedef valarray<CPP_tao_command_file_MATRIX>   CPP_tao_command_file_TENSOR;

class CPP_tao_common;
typedef valarray<CPP_tao_common>          CPP_tao_common_ARRAY;
typedef valarray<CPP_tao_common_ARRAY>    CPP_tao_common_MATRIX;
typedef valarray<CPP_tao_common_MATRIX>   CPP_tao_common_TENSOR;

class CPP_tao_lat_mode;
typedef valarray<CPP_tao_lat_mode>          CPP_tao_lat_mode_ARRAY;
typedef valarray<CPP_tao_lat_mode_ARRAY>    CPP_tao_lat_mode_MATRIX;
typedef valarray<CPP_tao_lat_mode_MATRIX>   CPP_tao_lat_mode_TENSOR;

class CPP_tao_sigma_mat;
typedef valarray<CPP_tao_sigma_mat>          CPP_tao_sigma_mat_ARRAY;
typedef valarray<CPP_tao_sigma_mat_ARRAY>    CPP_tao_sigma_mat_MATRIX;
typedef valarray<CPP_tao_sigma_mat_MATRIX>   CPP_tao_sigma_mat_TENSOR;

class CPP_tao_lattice_branch;
typedef valarray<CPP_tao_lattice_branch>          CPP_tao_lattice_branch_ARRAY;
typedef valarray<CPP_tao_lattice_branch_ARRAY>    CPP_tao_lattice_branch_MATRIX;
typedef valarray<CPP_tao_lattice_branch_MATRIX>   CPP_tao_lattice_branch_TENSOR;

class CPP_tao_lattice;
typedef valarray<CPP_tao_lattice>          CPP_tao_lattice_ARRAY;
typedef valarray<CPP_tao_lattice_ARRAY>    CPP_tao_lattice_MATRIX;
typedef valarray<CPP_tao_lattice_MATRIX>   CPP_tao_lattice_TENSOR;

class CPP_tao_element;
typedef valarray<CPP_tao_element>          CPP_tao_element_ARRAY;
typedef valarray<CPP_tao_element_ARRAY>    CPP_tao_element_MATRIX;
typedef valarray<CPP_tao_element_MATRIX>   CPP_tao_element_TENSOR;

class CPP_tao_ping_scale;
typedef valarray<CPP_tao_ping_scale>          CPP_tao_ping_scale_ARRAY;
typedef valarray<CPP_tao_ping_scale_ARRAY>    CPP_tao_ping_scale_MATRIX;
typedef valarray<CPP_tao_ping_scale_MATRIX>   CPP_tao_ping_scale_TENSOR;

class CPP_tao_universe_branch;
typedef valarray<CPP_tao_universe_branch>          CPP_tao_universe_branch_ARRAY;
typedef valarray<CPP_tao_universe_branch_ARRAY>    CPP_tao_universe_branch_MATRIX;
typedef valarray<CPP_tao_universe_branch_MATRIX>   CPP_tao_universe_branch_TENSOR;

class CPP_tao_beam;
typedef valarray<CPP_tao_beam>          CPP_tao_beam_ARRAY;
typedef valarray<CPP_tao_beam_ARRAY>    CPP_tao_beam_MATRIX;
typedef valarray<CPP_tao_beam_MATRIX>   CPP_tao_beam_TENSOR;

class CPP_tao_universe_calc;
typedef valarray<CPP_tao_universe_calc>          CPP_tao_universe_calc_ARRAY;
typedef valarray<CPP_tao_universe_calc_ARRAY>    CPP_tao_universe_calc_MATRIX;
typedef valarray<CPP_tao_universe_calc_MATRIX>   CPP_tao_universe_calc_TENSOR;

class CPP_tao_mpi;
typedef valarray<CPP_tao_mpi>          CPP_tao_mpi_ARRAY;
typedef valarray<CPP_tao_mpi_ARRAY>    CPP_tao_mpi_MATRIX;
typedef valarray<CPP_tao_mpi_MATRIX>   CPP_tao_mpi_TENSOR;

class CPP_tao_dynamic_aperture;
typedef valarray<CPP_tao_dynamic_aperture>          CPP_tao_dynamic_aperture_ARRAY;
typedef valarray<CPP_tao_dynamic_aperture_ARRAY>    CPP_tao_dynamic_aperture_MATRIX;
typedef valarray<CPP_tao_dynamic_aperture_MATRIX>   CPP_tao_dynamic_aperture_TENSOR;

class CPP_tao_universe;
typedef valarray<CPP_tao_universe>          CPP_tao_universe_ARRAY;
typedef valarray<CPP_tao_universe_ARRAY>    CPP_tao_universe_MATRIX;
typedef valarray<CPP_tao_universe_MATRIX>   CPP_tao_universe_TENSOR;

class CPP_tao_super_universe;
typedef valarray<CPP_tao_super_universe>          CPP_tao_super_universe_ARRAY;
typedef valarray<CPP_tao_super_universe_ARRAY>    CPP_tao_super_universe_MATRIX;
typedef valarray<CPP_tao_super_universe_MATRIX>   CPP_tao_super_universe_TENSOR;

//--------------------------------------------------------------------
// CPP_qp_rect

class Opaque_qp_rect_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_qp_rect {
public:
  Real x1;
  Real x2;
  Real y1;
  Real y2;
  string units;

  CPP_qp_rect() :
    x1(0.0),
    x2(0.0),
    y1(0.0),
    y2(0.0),
    units()
    {}

  ~CPP_qp_rect() {
  }

};   // End Class

extern "C" void qp_rect_to_c (const Opaque_qp_rect_class*, CPP_qp_rect&);
extern "C" void qp_rect_to_f (const CPP_qp_rect&, Opaque_qp_rect_class*);

bool operator== (const CPP_qp_rect&, const CPP_qp_rect&);


//--------------------------------------------------------------------
// CPP_qp_line

class Opaque_qp_line_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_qp_line {
public:
  Int width;
  Int color;
  Int pattern;

  CPP_qp_line() :
    width(1),
    color(Bmad::BLACK),
    pattern(Bmad::SOLID)
    {}

  ~CPP_qp_line() {
  }

};   // End Class

extern "C" void qp_line_to_c (const Opaque_qp_line_class*, CPP_qp_line&);
extern "C" void qp_line_to_f (const CPP_qp_line&, Opaque_qp_line_class*);

bool operator== (const CPP_qp_line&, const CPP_qp_line&);


//--------------------------------------------------------------------
// CPP_qp_symbol

class Opaque_qp_symbol_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_qp_symbol {
public:
  Int type;
  Real height;
  Int color;
  Int fill_pattern;
  Int line_width;

  CPP_qp_symbol() :
    type(Bmad::CIRCLE_DOT_SYM),
    height(10e0),
    color(Bmad::BLACK),
    fill_pattern(Bmad::SOLID_FILL),
    line_width(1)
    {}

  ~CPP_qp_symbol() {
  }

};   // End Class

extern "C" void qp_symbol_to_c (const Opaque_qp_symbol_class*, CPP_qp_symbol&);
extern "C" void qp_symbol_to_f (const CPP_qp_symbol&, Opaque_qp_symbol_class*);

bool operator== (const CPP_qp_symbol&, const CPP_qp_symbol&);


//--------------------------------------------------------------------
// CPP_qp_point

class Opaque_qp_point_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_qp_point {
public:
  Real x;
  Real y;
  string units;

  CPP_qp_point() :
    x(0.0),
    y(0.0),
    units()
    {}

  ~CPP_qp_point() {
  }

};   // End Class

extern "C" void qp_point_to_c (const Opaque_qp_point_class*, CPP_qp_point&);
extern "C" void qp_point_to_f (const CPP_qp_point&, Opaque_qp_point_class*);

bool operator== (const CPP_qp_point&, const CPP_qp_point&);


//--------------------------------------------------------------------
// CPP_qp_axis

class Opaque_qp_axis_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_qp_axis {
public:
  string label;
  Real min;
  Real max;
  Real number_offset;
  Real label_offset;
  Real major_tick_len;
  Real minor_tick_len;
  Int label_color;
  Int major_div;
  Int major_div_nominal;
  Int minor_div;
  Int minor_div_max;
  Int places;
  string type;
  string bounds;
  Int tick_side;
  Int number_side;
  Bool draw_label;
  Bool draw_numbers;

  CPP_qp_axis() :
    label(),
    min(0.0),
    max(10),
    number_offset(0.05),
    label_offset(0.05),
    major_tick_len(0.10),
    minor_tick_len(0.06),
    label_color(Bmad::BLACK),
    major_div(5),
    major_div_nominal(5),
    minor_div(0),
    minor_div_max(5),
    places(0),
    type(),
    bounds(),
    tick_side(+1),
    number_side(-1),
    draw_label(true),
    draw_numbers(true)
    {}

  ~CPP_qp_axis() {
  }

};   // End Class

extern "C" void qp_axis_to_c (const Opaque_qp_axis_class*, CPP_qp_axis&);
extern "C" void qp_axis_to_f (const CPP_qp_axis&, Opaque_qp_axis_class*);

bool operator== (const CPP_qp_axis&, const CPP_qp_axis&);


//--------------------------------------------------------------------
// CPP_tao_cmd_history

class Opaque_tao_cmd_history_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_cmd_history {
public:
  string* cmd;
  Int ix;
  Bool cmd_file;

  CPP_tao_cmd_history() :
    cmd(NULL),
    ix(0),
    cmd_file(false)
    {}

  ~CPP_tao_cmd_history() {
    delete cmd;
  }

};   // End Class

extern "C" void tao_cmd_history_to_c (const Opaque_tao_cmd_history_class*, CPP_tao_cmd_history&);
extern "C" void tao_cmd_history_to_f (const CPP_tao_cmd_history&, Opaque_tao_cmd_history_class*);

bool operator== (const CPP_tao_cmd_history&, const CPP_tao_cmd_history&);


//--------------------------------------------------------------------
// CPP_tao_real_pointer

class Opaque_tao_real_pointer_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_real_pointer {
public:
  Real* r;
  Bool* good_value;
  Bool* good_user;

  CPP_tao_real_pointer() :
    r(NULL),
    good_value(NULL),
    good_user(NULL)
    {}

  ~CPP_tao_real_pointer() {
    delete good_value;
    delete good_user;
  }

};   // End Class

extern "C" void tao_real_pointer_to_c (const Opaque_tao_real_pointer_class*, CPP_tao_real_pointer&);
extern "C" void tao_real_pointer_to_f (const CPP_tao_real_pointer&, Opaque_tao_real_pointer_class*);

bool operator== (const CPP_tao_real_pointer&, const CPP_tao_real_pointer&);


//--------------------------------------------------------------------
// CPP_tao_logical_array

class Opaque_tao_logical_array_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_logical_array {
public:
  Bool* l;

  CPP_tao_logical_array() :
    l(NULL)
    {}

  ~CPP_tao_logical_array() {
  }

};   // End Class

extern "C" void tao_logical_array_to_c (const Opaque_tao_logical_array_class*, CPP_tao_logical_array&);
extern "C" void tao_logical_array_to_f (const CPP_tao_logical_array&, Opaque_tao_logical_array_class*);

bool operator== (const CPP_tao_logical_array&, const CPP_tao_logical_array&);


//--------------------------------------------------------------------
// CPP_tao_integer_array

class Opaque_tao_integer_array_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_integer_array {
public:
  Int* i;

  CPP_tao_integer_array() :
    i(NULL)
    {}

  ~CPP_tao_integer_array() {
  }

};   // End Class

extern "C" void tao_integer_array_to_c (const Opaque_tao_integer_array_class*, CPP_tao_integer_array&);
extern "C" void tao_integer_array_to_f (const CPP_tao_integer_array&, Opaque_tao_integer_array_class*);

bool operator== (const CPP_tao_integer_array&, const CPP_tao_integer_array&);


//--------------------------------------------------------------------
// CPP_tao_expression_info

class Opaque_tao_expression_info_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_expression_info {
public:
  Bool good;
  Int ix_ele;
  Real s;

  CPP_tao_expression_info() :
    good(true),
    ix_ele(-1),
    s(Bmad::REAL_GARBAGE)
    {}

  ~CPP_tao_expression_info() {
  }

};   // End Class

extern "C" void tao_expression_info_to_c (const Opaque_tao_expression_info_class*, CPP_tao_expression_info&);
extern "C" void tao_expression_info_to_f (const CPP_tao_expression_info&, Opaque_tao_expression_info_class*);

bool operator== (const CPP_tao_expression_info&, const CPP_tao_expression_info&);


//--------------------------------------------------------------------
// CPP_tao_eval_stack1

class Opaque_tao_eval_stack1_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_eval_stack1 {
public:
  Int type;
  string name;
  Real scale;
  Real_ARRAY value;
  CPP_tao_expression_info_ARRAY info;
  CPP_tao_real_pointer_ARRAY value_ptr;

  CPP_tao_eval_stack1() :
    type(0),
    name(),
    scale(1),
    value(0.0, 0),
    info(CPP_tao_expression_info_ARRAY(CPP_tao_expression_info(), 0)),
    value_ptr(CPP_tao_real_pointer_ARRAY(CPP_tao_real_pointer(), 0))
    {}

  ~CPP_tao_eval_stack1() {
  }

};   // End Class

extern "C" void tao_eval_stack1_to_c (const Opaque_tao_eval_stack1_class*, CPP_tao_eval_stack1&);
extern "C" void tao_eval_stack1_to_f (const CPP_tao_eval_stack1&, Opaque_tao_eval_stack1_class*);

bool operator== (const CPP_tao_eval_stack1&, const CPP_tao_eval_stack1&);


//--------------------------------------------------------------------
// CPP_tao_ele_shape

class Opaque_tao_ele_shape_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_ele_shape {
public:
  string ele_id;
  string shape;
  string color;
  Real size;
  string label;
  Bool draw;
  Bool multi;
  Int ix_ele_key;
  string name_ele;

  CPP_tao_ele_shape() :
    ele_id(),
    shape(),
    color(),
    size(0.0),
    label(),
    draw(true),
    multi(false),
    ix_ele_key(0),
    name_ele()
    {}

  ~CPP_tao_ele_shape() {
  }

};   // End Class

extern "C" void tao_ele_shape_to_c (const Opaque_tao_ele_shape_class*, CPP_tao_ele_shape&);
extern "C" void tao_ele_shape_to_f (const CPP_tao_ele_shape&, Opaque_tao_ele_shape_class*);

bool operator== (const CPP_tao_ele_shape&, const CPP_tao_ele_shape&);


//--------------------------------------------------------------------
// CPP_tao_pattern_point

class Opaque_tao_pattern_point_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_pattern_point {
public:
  Real s;
  Real x;
  Real radius;

  CPP_tao_pattern_point() :
    s(Bmad::REAL_GARBAGE),
    x(Bmad::REAL_GARBAGE),
    radius(0.0)
    {}

  ~CPP_tao_pattern_point() {
  }

};   // End Class

extern "C" void tao_pattern_point_to_c (const Opaque_tao_pattern_point_class*, CPP_tao_pattern_point&);
extern "C" void tao_pattern_point_to_f (const CPP_tao_pattern_point&, Opaque_tao_pattern_point_class*);

bool operator== (const CPP_tao_pattern_point&, const CPP_tao_pattern_point&);


//--------------------------------------------------------------------
// CPP_tao_pattern_curve

class Opaque_tao_pattern_curve_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_pattern_curve {
public:
  CPP_qp_line line;
  CPP_tao_pattern_point_ARRAY pt;
  string scale;

  CPP_tao_pattern_curve() :
    line(),
    pt(CPP_tao_pattern_point_ARRAY(CPP_tao_pattern_point(), 0)),
    scale()
    {}

  ~CPP_tao_pattern_curve() {
  }

};   // End Class

extern "C" void tao_pattern_curve_to_c (const Opaque_tao_pattern_curve_class*, CPP_tao_pattern_curve&);
extern "C" void tao_pattern_curve_to_f (const CPP_tao_pattern_curve&, Opaque_tao_pattern_curve_class*);

bool operator== (const CPP_tao_pattern_curve&, const CPP_tao_pattern_curve&);


//--------------------------------------------------------------------
// CPP_tao_shape_pattern

class Opaque_tao_shape_pattern_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_shape_pattern {
public:
  string name;
  CPP_tao_pattern_curve_ARRAY curve;

  CPP_tao_shape_pattern() :
    name(),
    curve(CPP_tao_pattern_curve_ARRAY(CPP_tao_pattern_curve(), 0))
    {}

  ~CPP_tao_shape_pattern() {
  }

};   // End Class

extern "C" void tao_shape_pattern_to_c (const Opaque_tao_shape_pattern_class*, CPP_tao_shape_pattern&);
extern "C" void tao_shape_pattern_to_f (const CPP_tao_shape_pattern&, Opaque_tao_shape_pattern_class*);

bool operator== (const CPP_tao_shape_pattern&, const CPP_tao_shape_pattern&);


//--------------------------------------------------------------------
// CPP_tao_drawing

class Opaque_tao_drawing_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_drawing {
public:
  CPP_tao_ele_shape_ARRAY ele_shape;

  CPP_tao_drawing() :
    ele_shape(CPP_tao_ele_shape_ARRAY(CPP_tao_ele_shape(), 0))
    {}

  ~CPP_tao_drawing() {
  }

};   // End Class

extern "C" void tao_drawing_to_c (const Opaque_tao_drawing_class*, CPP_tao_drawing&);
extern "C" void tao_drawing_to_f (const CPP_tao_drawing&, Opaque_tao_drawing_class*);

bool operator== (const CPP_tao_drawing&, const CPP_tao_drawing&);


//--------------------------------------------------------------------
// CPP_tao_wave_kick_pt

class Opaque_tao_wave_kick_pt_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_wave_kick_pt {
public:
  Real phi_s;
  Real phi_r;
  Real phi;
  Real amp;
  Int ix_dat;

  CPP_tao_wave_kick_pt() :
    phi_s(0.0),
    phi_r(0.0),
    phi(0.0),
    amp(0.0),
    ix_dat(0)
    {}

  ~CPP_tao_wave_kick_pt() {
  }

};   // End Class

extern "C" void tao_wave_kick_pt_to_c (const Opaque_tao_wave_kick_pt_class*, CPP_tao_wave_kick_pt&);
extern "C" void tao_wave_kick_pt_to_f (const CPP_tao_wave_kick_pt&, Opaque_tao_wave_kick_pt_class*);

bool operator== (const CPP_tao_wave_kick_pt&, const CPP_tao_wave_kick_pt&);


//--------------------------------------------------------------------
// CPP_tao_wave

class Opaque_tao_wave_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_wave {
public:
  string data_type;
  Real rms_rel_a;
  Real rms_rel_b;
  Real rms_rel_as;
  Real rms_rel_bs;
  Real rms_rel_ar;
  Real rms_rel_br;
  Real rms_rel_k;
  Real rms_rel_ks;
  Real rms_rel_kr;
  Real rms_phi;
  Real rms_phi_s;
  Real rms_phi_r;
  Real amp_ba_s;
  Real amp_ba_r;
  Real chi_a;
  Real chi_c;
  Real chi_ba;
  Real_ARRAY amp_a;
  Real_ARRAY amp_b;
  Real_ARRAY amp_ba;
  Real_ARRAY coef_a;
  Real_ARRAY coef_b;
  Real_ARRAY coef_ba;
  Int n_func;
  Int ix_a1;
  Int ix_a2;
  Int ix_b1;
  Int ix_b2;
  Int i_a1;
  Int i_a2;
  Int i_b1;
  Int i_b2;
  Int n_a;
  Int n_b;
  Int i_wrap_pt;
  Int_ARRAY ix_data;
  Int n_kick;
  CPP_tao_wave_kick_pt_ARRAY kick;
  CPP_tao_graph graph;
  CPP_ele ele;

  CPP_tao_wave() :
    data_type(),
    rms_rel_a(0.0),
    rms_rel_b(0.0),
    rms_rel_as(0.0),
    rms_rel_bs(0.0),
    rms_rel_ar(0.0),
    rms_rel_br(0.0),
    rms_rel_k(0.0),
    rms_rel_ks(0.0),
    rms_rel_kr(0.0),
    rms_phi(0.0),
    rms_phi_s(0.0),
    rms_phi_r(0.0),
    amp_ba_s(0.0),
    amp_ba_r(0.0),
    chi_a(0.0),
    chi_c(0.0),
    chi_ba(0.0),
    amp_a(0.0, 2),
    amp_b(0.0, 2),
    amp_ba(0.0, 2),
    coef_a(0.0, 4),
    coef_b(0.0, 4),
    coef_ba(0.0, 4),
    n_func(0),
    ix_a1(-1),
    ix_a2(-1),
    ix_b1(-1),
    ix_b2(-1),
    i_a1(0),
    i_a2(0),
    i_b1(0),
    i_b2(0),
    n_a(0),
    n_b(0),
    i_wrap_pt(0),
    ix_data(0, 0),
    n_kick(0),
    kick(CPP_tao_wave_kick_pt_ARRAY(CPP_tao_wave_kick_pt(), 0)),
    graph(),
    ele()
    {}

  ~CPP_tao_wave() {
  }

};   // End Class

extern "C" void tao_wave_to_c (const Opaque_tao_wave_class*, CPP_tao_wave&);
extern "C" void tao_wave_to_f (const CPP_tao_wave&, Opaque_tao_wave_class*);

bool operator== (const CPP_tao_wave&, const CPP_tao_wave&);


//--------------------------------------------------------------------
// CPP_tao_title

class Opaque_tao_title_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_title {
public:
  string title;
  Real x;
  Real y;
  string units;
  string justify;
  Bool draw_it;

  CPP_tao_title() :
    title(),
    x(0.5),
    y(0.97),
    units(),
    justify(),
    draw_it(true)
    {}

  ~CPP_tao_title() {
  }

};   // End Class

extern "C" void tao_title_to_c (const Opaque_tao_title_class*, CPP_tao_title&);
extern "C" void tao_title_to_f (const CPP_tao_title&, Opaque_tao_title_class*);

bool operator== (const CPP_tao_title&, const CPP_tao_title&);


//--------------------------------------------------------------------
// CPP_tao_data_var_component

class Opaque_tao_data_var_component_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_data_var_component {
public:
  string name;
  Real sign;

  CPP_tao_data_var_component() :
    name(),
    sign(1)
    {}

  ~CPP_tao_data_var_component() {
  }

};   // End Class

extern "C" void tao_data_var_component_to_c (const Opaque_tao_data_var_component_class*, CPP_tao_data_var_component&);
extern "C" void tao_data_var_component_to_f (const CPP_tao_data_var_component&, Opaque_tao_data_var_component_class*);

bool operator== (const CPP_tao_data_var_component&, const CPP_tao_data_var_component&);


//--------------------------------------------------------------------
// CPP_tao_histogram

class Opaque_tao_histogram_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_histogram {
public:
  Bool density_normalized;
  Bool weight_by_charge;
  Real minimum;
  Real maximum;
  Real width;
  Real center;
  Int number;

  CPP_tao_histogram() :
    density_normalized(false),
    weight_by_charge(true),
    minimum(0.0),
    maximum(0.0),
    width(0.0),
    center(0.0),
    number(0)
    {}

  ~CPP_tao_histogram() {
  }

};   // End Class

extern "C" void tao_histogram_to_c (const Opaque_tao_histogram_class*, CPP_tao_histogram&);
extern "C" void tao_histogram_to_f (const CPP_tao_histogram&, Opaque_tao_histogram_class*);

bool operator== (const CPP_tao_histogram&, const CPP_tao_histogram&);


//--------------------------------------------------------------------
// CPP_tao_curve

class Opaque_tao_curve_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_curve {
public:
  string name;
  string data_source;
  string data_index;
  string data_type_x;
  string data_type_z;
  string data_type;
  string ele_ref_name;
  string legend_text;
  string message_text;
  string units;
  string component;
  CPP_tao_graph* g;
  CPP_tao_histogram hist;
  Real_ARRAY x_line;
  Real_ARRAY y_line;
  Real_ARRAY y2_line;
  Int_ARRAY ix_line;
  Real_ARRAY x_symb;
  Real_ARRAY y_symb;
  Real_ARRAY z_symb;
  Real_ARRAY symb_size;
  Int_ARRAY ix_symb;
  Real y_axis_scale_factor;
  Real s;
  Real z_color0;
  Real z_color1;
  CPP_qp_line line;
  CPP_qp_symbol symbol;
  Int ix_universe;
  Int symbol_every;
  Int ix_branch;
  Int ix_ele_ref;
  Int ix_ele_ref_track;
  Int ix_bunch;
  Bool use_y2;
  Bool draw_line;
  Bool draw_symbols;
  Bool draw_symbol_index;
  Bool smooth_line_calc;
  Bool use_z_color;
  Bool autoscale_z_color;

  CPP_tao_curve() :
    name(),
    data_source(),
    data_index(),
    data_type_x(),
    data_type_z(),
    data_type(),
    ele_ref_name(),
    legend_text(),
    message_text(),
    units(),
    component(),
    g(NULL),
    hist(),
    x_line(0.0, 0),
    y_line(0.0, 0),
    y2_line(0.0, 0),
    ix_line(0, 0),
    x_symb(0.0, 0),
    y_symb(0.0, 0),
    z_symb(0.0, 0),
    symb_size(0.0, 0),
    ix_symb(0, 0),
    y_axis_scale_factor(1),
    s(0.0),
    z_color0(0.0),
    z_color1(0.0),
    line(),
    symbol(),
    ix_universe(-1),
    symbol_every(1),
    ix_branch(0),
    ix_ele_ref(-1),
    ix_ele_ref_track(-1),
    ix_bunch(0),
    use_y2(false),
    draw_line(true),
    draw_symbols(true),
    draw_symbol_index(false),
    smooth_line_calc(true),
    use_z_color(false),
    autoscale_z_color(true)
    {}

  ~CPP_tao_curve() {
  }

};   // End Class

extern "C" void tao_curve_to_c (const Opaque_tao_curve_class*, CPP_tao_curve&);
extern "C" void tao_curve_to_f (const CPP_tao_curve&, Opaque_tao_curve_class*);

bool operator== (const CPP_tao_curve&, const CPP_tao_curve&);


//--------------------------------------------------------------------
// CPP_tao_graph

class Opaque_tao_graph_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_graph {
public:
  string name;
  string type;
  string title;
  string title_suffix;
  String_ARRAY text_legend;
  string component;
  string why_invalid;
  string floor_plan_view;
  string floor_plan_orbit_color;
  CPP_tao_curve_ARRAY curve;
  CPP_tao_plot* p;
  CPP_qp_point text_legend_origin;
  CPP_qp_point curve_legend_origin;
  CPP_qp_axis x;
  CPP_qp_axis y;
  CPP_qp_axis y2;
  CPP_qp_rect margin;
  CPP_qp_rect scale_margin;
  Real x_axis_scale_factor;
  Real symbol_size_scale;
  Real floor_plan_rotation;
  Real floor_plan_orbit_scale;
  Int_ARRAY box;
  Int ix_branch;
  Int ix_universe;
  Bool clip;
  Bool valid;
  Bool y2_mirrors_y;
  Bool limited;
  Bool draw_axes;
  Bool correct_xy_distortion;
  Bool floor_plan_size_is_absolute;
  Bool floor_plan_draw_only_first_pass;
  Bool draw_curve_legend;
  Bool draw_grid;
  Bool allow_wrap_around;
  Bool draw_only_good_user_data_or_vars;

  CPP_tao_graph() :
    name(),
    type(),
    title(),
    title_suffix(),
    text_legend(String_ARRAY(string(), 10)),
    component(),
    why_invalid(),
    floor_plan_view(),
    floor_plan_orbit_color(),
    curve(CPP_tao_curve_ARRAY(CPP_tao_curve(), 0)),
    p(NULL),
    text_legend_origin(),
    curve_legend_origin(),
    x(),
    y(),
    y2(),
    margin(),
    scale_margin(),
    x_axis_scale_factor(1),
    symbol_size_scale(0.0),
    floor_plan_rotation(0.0),
    floor_plan_orbit_scale(0.0),
    box(0, 4),
    ix_branch(0),
    ix_universe(-1),
    clip(false),
    valid(false),
    y2_mirrors_y(false),
    limited(false),
    draw_axes(true),
    correct_xy_distortion(true),
    floor_plan_size_is_absolute(false),
    floor_plan_draw_only_first_pass(false),
    draw_curve_legend(true),
    draw_grid(true),
    allow_wrap_around(true),
    draw_only_good_user_data_or_vars(true)
    {}

  ~CPP_tao_graph() {
  }

};   // End Class

extern "C" void tao_graph_to_c (const Opaque_tao_graph_class*, CPP_tao_graph&);
extern "C" void tao_graph_to_f (const CPP_tao_graph&, Opaque_tao_graph_class*);

bool operator== (const CPP_tao_graph&, const CPP_tao_graph&);


//--------------------------------------------------------------------
// CPP_tao_plot

class Opaque_tao_plot_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_plot {
public:
  string name;
  string description;
  CPP_tao_graph_ARRAY graph;
  CPP_qp_axis x;
  CPP_tao_plot_region* r;
  Int n_curve_pts;
  string type;
  string x_axis_type;
  Bool autoscale_x;
  Bool autoscale_y;
  Bool autoscale_gang_x;
  Bool autoscale_gang_y;
  Bool list_with_show_plot_command;
  Bool phantom;

  CPP_tao_plot() :
    name(),
    description(),
    graph(CPP_tao_graph_ARRAY(CPP_tao_graph(), 0)),
    x(),
    r(NULL),
    n_curve_pts(-1),
    type(),
    x_axis_type(),
    autoscale_x(false),
    autoscale_y(false),
    autoscale_gang_x(true),
    autoscale_gang_y(true),
    list_with_show_plot_command(true),
    phantom(false)
    {}

  ~CPP_tao_plot() {
  }

};   // End Class

extern "C" void tao_plot_to_c (const Opaque_tao_plot_class*, CPP_tao_plot&);
extern "C" void tao_plot_to_f (const CPP_tao_plot&, Opaque_tao_plot_class*);

bool operator== (const CPP_tao_plot&, const CPP_tao_plot&);


//--------------------------------------------------------------------
// CPP_tao_plot_region

class Opaque_tao_plot_region_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_plot_region {
public:
  string name;
  CPP_tao_plot plot;
  Real_ARRAY location;
  Bool visible;
  Bool list_with_show_plot_command;

  CPP_tao_plot_region() :
    name(),
    plot(),
    location(0.0, 4),
    visible(false),
    list_with_show_plot_command(true)
    {}

  ~CPP_tao_plot_region() {
  }

};   // End Class

extern "C" void tao_plot_region_to_c (const Opaque_tao_plot_region_class*, CPP_tao_plot_region&);
extern "C" void tao_plot_region_to_f (const CPP_tao_plot_region&, Opaque_tao_plot_region_class*);

bool operator== (const CPP_tao_plot_region&, const CPP_tao_plot_region&);


//--------------------------------------------------------------------
// CPP_tao_plot_page

class Opaque_tao_plot_page_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_plot_page {
public:
  CPP_tao_title_ARRAY title;
  CPP_qp_rect border;
  CPP_tao_drawing floor_plan;
  CPP_tao_drawing lat_layout;
  CPP_tao_shape_pattern_ARRAY pattern;
  CPP_tao_plot_ARRAY plot_template;
  CPP_tao_plot_region_ARRAY region;
  string plot_display_type;
  string ps_scale;
  Real_ARRAY size;
  Real text_height;
  Real main_title_text_scale;
  Real graph_title_text_scale;
  Real axis_number_text_scale;
  Real axis_label_text_scale;
  Real legend_text_scale;
  Real key_table_text_scale;
  Real curve_legend_line_len;
  Real curve_legend_text_offset;
  Real floor_plan_shape_scale;
  Real lat_layout_shape_scale;
  Int n_curve_pts;
  Int id_window;
  Bool delete_overlapping_plots;

  CPP_tao_plot_page() :
    title(CPP_tao_title_ARRAY(CPP_tao_title(), 2)),
    border(),
    floor_plan(),
    lat_layout(),
    pattern(CPP_tao_shape_pattern_ARRAY(CPP_tao_shape_pattern(), 0)),
    plot_template(CPP_tao_plot_ARRAY(CPP_tao_plot(), 0)),
    region(CPP_tao_plot_region_ARRAY(CPP_tao_plot_region(), 0)),
    plot_display_type(),
    ps_scale(),
    size(0.0, 2),
    text_height(12),
    main_title_text_scale(1.3),
    graph_title_text_scale(1.1),
    axis_number_text_scale(0.9),
    axis_label_text_scale(1.0),
    legend_text_scale(0.7),
    key_table_text_scale(0.9),
    curve_legend_line_len(50),
    curve_legend_text_offset(10),
    floor_plan_shape_scale(1.0),
    lat_layout_shape_scale(1.0),
    n_curve_pts(401),
    id_window(-1),
    delete_overlapping_plots(true)
    {}

  ~CPP_tao_plot_page() {
  }

};   // End Class

extern "C" void tao_plot_page_to_c (const Opaque_tao_plot_page_class*, CPP_tao_plot_page&);
extern "C" void tao_plot_page_to_f (const CPP_tao_plot_page&, Opaque_tao_plot_page_class*);

bool operator== (const CPP_tao_plot_page&, const CPP_tao_plot_page&);


//--------------------------------------------------------------------
// CPP_tao_plot_array

class Opaque_tao_plot_array_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_plot_array {
public:
  CPP_tao_plot* p;

  CPP_tao_plot_array() :
    p(NULL)
    {}

  ~CPP_tao_plot_array() {
  }

};   // End Class

extern "C" void tao_plot_array_to_c (const Opaque_tao_plot_array_class*, CPP_tao_plot_array&);
extern "C" void tao_plot_array_to_f (const CPP_tao_plot_array&, Opaque_tao_plot_array_class*);

bool operator== (const CPP_tao_plot_array&, const CPP_tao_plot_array&);


//--------------------------------------------------------------------
// CPP_tao_graph_array

class Opaque_tao_graph_array_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_graph_array {
public:
  CPP_tao_graph* g;

  CPP_tao_graph_array() :
    g(NULL)
    {}

  ~CPP_tao_graph_array() {
  }

};   // End Class

extern "C" void tao_graph_array_to_c (const Opaque_tao_graph_array_class*, CPP_tao_graph_array&);
extern "C" void tao_graph_array_to_f (const CPP_tao_graph_array&, Opaque_tao_graph_array_class*);

bool operator== (const CPP_tao_graph_array&, const CPP_tao_graph_array&);


//--------------------------------------------------------------------
// CPP_tao_curve_array

class Opaque_tao_curve_array_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_curve_array {
public:
  CPP_tao_curve* c;

  CPP_tao_curve_array() :
    c(NULL)
    {}

  ~CPP_tao_curve_array() {
  }

};   // End Class

extern "C" void tao_curve_array_to_c (const Opaque_tao_curve_array_class*, CPP_tao_curve_array&);
extern "C" void tao_curve_array_to_f (const CPP_tao_curve_array&, Opaque_tao_curve_array_class*);

bool operator== (const CPP_tao_curve_array&, const CPP_tao_curve_array&);


//--------------------------------------------------------------------
// CPP_tao_data

class Opaque_tao_data_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_data {
public:
  string ele_name;
  string ele_start_name;
  string ele_ref_name;
  string data_type;
  string merit_type;
  string data_source;
  Int ix_bunch;
  Int ix_branch;
  Int ix_ele;
  Int ix_ele_start;
  Int ix_ele_ref;
  Int ix_ele_merit;
  Int ix_d1;
  Int ix_data;
  Int ix_dmodel;
  Int eval_point;
  Real meas_value;
  Real ref_value;
  Real model_value;
  Real design_value;
  Real old_value;
  Real base_value;
  Real delta_merit;
  Real weight;
  Real invalid_value;
  Real merit;
  Real s;
  Real s_offset;
  Bool exists;
  Bool good_model;
  Bool good_base;
  Bool good_design;
  Bool good_meas;
  Bool good_ref;
  Bool good_user;
  Bool good_opt;
  Bool good_plot;
  Bool useit_plot;
  Bool useit_opt;
  CPP_tao_d1_data* d1;
  CPP_tao_eval_stack1_ARRAY stack;

  CPP_tao_data() :
    ele_name(),
    ele_start_name(),
    ele_ref_name(),
    data_type(),
    merit_type(),
    data_source(),
    ix_bunch(0),
    ix_branch(0),
    ix_ele(-1),
    ix_ele_start(-1),
    ix_ele_ref(-1),
    ix_ele_merit(0),
    ix_d1(0),
    ix_data(-1),
    ix_dmodel(-1),
    eval_point(Bmad::ANCHOR_END),
    meas_value(0.0),
    ref_value(0.0),
    model_value(0.0),
    design_value(0.0),
    old_value(0.0),
    base_value(0.0),
    delta_merit(0.0),
    weight(0.0),
    invalid_value(0.0),
    merit(0.0),
    s(0.0),
    s_offset(0.0),
    exists(false),
    good_model(false),
    good_base(false),
    good_design(false),
    good_meas(false),
    good_ref(false),
    good_user(true),
    good_opt(true),
    good_plot(false),
    useit_plot(false),
    useit_opt(false),
    d1(NULL),
    stack(CPP_tao_eval_stack1_ARRAY(CPP_tao_eval_stack1(), 0))
    {}

  ~CPP_tao_data() {
  }

};   // End Class

extern "C" void tao_data_to_c (const Opaque_tao_data_class*, CPP_tao_data&);
extern "C" void tao_data_to_f (const CPP_tao_data&, Opaque_tao_data_class*);

bool operator== (const CPP_tao_data&, const CPP_tao_data&);


//--------------------------------------------------------------------
// CPP_tao_d1_data

class Opaque_tao_d1_data_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_d1_data {
public:
  string name;
  CPP_tao_d2_data* d2;
  CPP_tao_data_ARRAY d;

  CPP_tao_d1_data() :
    name(),
    d2(NULL),
    d(CPP_tao_data_ARRAY(CPP_tao_data(), 0))
    {}

  ~CPP_tao_d1_data() {
  }

};   // End Class

extern "C" void tao_d1_data_to_c (const Opaque_tao_d1_data_class*, CPP_tao_d1_data&);
extern "C" void tao_d1_data_to_f (const CPP_tao_d1_data&, Opaque_tao_d1_data_class*);

bool operator== (const CPP_tao_d1_data&, const CPP_tao_d1_data&);


//--------------------------------------------------------------------
// CPP_tao_d2_data

class Opaque_tao_d2_data_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_d2_data {
public:
  string name;
  string data_file_name;
  string ref_file_name;
  string data_date;
  string ref_date;
  String_ARRAY descrip;
  CPP_tao_d1_data_ARRAY d1;
  Int ix_uni;
  Int ix_d2_data;
  Int ix_data;
  Int ix_ref;
  Bool data_read_in;
  Bool ref_read_in;

  CPP_tao_d2_data() :
    name(),
    data_file_name(),
    ref_file_name(),
    data_date(),
    ref_date(),
    descrip(String_ARRAY(string(), 10)),
    d1(CPP_tao_d1_data_ARRAY(CPP_tao_d1_data(), 0)),
    ix_uni(0),
    ix_d2_data(0),
    ix_data(0),
    ix_ref(0),
    data_read_in(false),
    ref_read_in(false)
    {}

  ~CPP_tao_d2_data() {
  }

};   // End Class

extern "C" void tao_d2_data_to_c (const Opaque_tao_d2_data_class*, CPP_tao_d2_data&);
extern "C" void tao_d2_data_to_f (const CPP_tao_d2_data&, Opaque_tao_d2_data_class*);

bool operator== (const CPP_tao_d2_data&, const CPP_tao_d2_data&);


//--------------------------------------------------------------------
// CPP_tao_data_array

class Opaque_tao_data_array_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_data_array {
public:
  CPP_tao_data* d;

  CPP_tao_data_array() :
    d(NULL)
    {}

  ~CPP_tao_data_array() {
  }

};   // End Class

extern "C" void tao_data_array_to_c (const Opaque_tao_data_array_class*, CPP_tao_data_array&);
extern "C" void tao_data_array_to_f (const CPP_tao_data_array&, Opaque_tao_data_array_class*);

bool operator== (const CPP_tao_data_array&, const CPP_tao_data_array&);


//--------------------------------------------------------------------
// CPP_tao_d1_data_array

class Opaque_tao_d1_data_array_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_d1_data_array {
public:
  CPP_tao_d1_data* d1;

  CPP_tao_d1_data_array() :
    d1(NULL)
    {}

  ~CPP_tao_d1_data_array() {
  }

};   // End Class

extern "C" void tao_d1_data_array_to_c (const Opaque_tao_d1_data_array_class*, CPP_tao_d1_data_array&);
extern "C" void tao_d1_data_array_to_f (const CPP_tao_d1_data_array&, Opaque_tao_d1_data_array_class*);

bool operator== (const CPP_tao_d1_data_array&, const CPP_tao_d1_data_array&);


//--------------------------------------------------------------------
// CPP_tao_d2_data_array

class Opaque_tao_d2_data_array_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_d2_data_array {
public:
  CPP_tao_d2_data* d2;

  CPP_tao_d2_data_array() :
    d2(NULL)
    {}

  ~CPP_tao_d2_data_array() {
  }

};   // End Class

extern "C" void tao_d2_data_array_to_c (const Opaque_tao_d2_data_array_class*, CPP_tao_d2_data_array&);
extern "C" void tao_d2_data_array_to_f (const CPP_tao_d2_data_array&, Opaque_tao_d2_data_array_class*);

bool operator== (const CPP_tao_d2_data_array&, const CPP_tao_d2_data_array&);


//--------------------------------------------------------------------
// CPP_tao_var_slave

class Opaque_tao_var_slave_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_var_slave {
public:
  Int ix_uni;
  Int ix_branch;
  Int ix_ele;
  Real* model_value;
  Real* base_value;

  CPP_tao_var_slave() :
    ix_uni(1),
    ix_branch(0),
    ix_ele(-1),
    model_value(NULL),
    base_value(NULL)
    {}

  ~CPP_tao_var_slave() {
    delete model_value;
    delete base_value;
  }

};   // End Class

extern "C" void tao_var_slave_to_c (const Opaque_tao_var_slave_class*, CPP_tao_var_slave&);
extern "C" void tao_var_slave_to_f (const CPP_tao_var_slave&, Opaque_tao_var_slave_class*);

bool operator== (const CPP_tao_var_slave&, const CPP_tao_var_slave&);


//--------------------------------------------------------------------
// CPP_tao_var

class Opaque_tao_var_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_var {
public:
  string ele_name;
  string attrib_name;
  CPP_tao_var_slave_ARRAY slave;
  CPP_tao_var_slave common_slave;
  Int ix_v1;
  Int ix_var;
  Int ix_dvar;
  Int ix_attrib;
  Int ix_key_table;
  Real* model_value;
  Real* base_value;
  Real design_value;
  Real scratch_value;
  Real old_value;
  Real meas_value;
  Real ref_value;
  Real correction_value;
  Real high_lim;
  Real low_lim;
  Real step;
  Real weight;
  Real delta_merit;
  Real merit;
  Real dmerit_dvar;
  Real key_val0;
  Real key_delta;
  Real s;
  string merit_type;
  Bool exists;
  Bool good_var;
  Bool good_user;
  Bool good_opt;
  Bool good_plot;
  Bool useit_opt;
  Bool useit_plot;
  Bool key_bound;
  CPP_tao_v1_var* v1;

  CPP_tao_var() :
    ele_name(),
    attrib_name(),
    slave(CPP_tao_var_slave_ARRAY(CPP_tao_var_slave(), 0)),
    common_slave(),
    ix_v1(0),
    ix_var(0),
    ix_dvar(-1),
    ix_attrib(0),
    ix_key_table(0),
    model_value(NULL),
    base_value(NULL),
    design_value(0.0),
    scratch_value(0.0),
    old_value(0.0),
    meas_value(0.0),
    ref_value(0.0),
    correction_value(0.0),
    high_lim(0.0),
    low_lim(0.0),
    step(0.0),
    weight(0.0),
    delta_merit(0.0),
    merit(0.0),
    dmerit_dvar(0.0),
    key_val0(0.0),
    key_delta(0.0),
    s(0.0),
    merit_type(),
    exists(false),
    good_var(false),
    good_user(false),
    good_opt(false),
    good_plot(false),
    useit_opt(false),
    useit_plot(false),
    key_bound(false),
    v1(NULL)
    {}

  ~CPP_tao_var() {
  }

};   // End Class

extern "C" void tao_var_to_c (const Opaque_tao_var_class*, CPP_tao_var&);
extern "C" void tao_var_to_f (const CPP_tao_var&, Opaque_tao_var_class*);

bool operator== (const CPP_tao_var&, const CPP_tao_var&);


//--------------------------------------------------------------------
// CPP_tao_v1_var

class Opaque_tao_v1_var_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_v1_var {
public:
  string name;
  Int ix_v1_var;
  CPP_tao_var_ARRAY v;

  CPP_tao_v1_var() :
    name(),
    ix_v1_var(0),
    v(CPP_tao_var_ARRAY(CPP_tao_var(), 0))
    {}

  ~CPP_tao_v1_var() {
  }

};   // End Class

extern "C" void tao_v1_var_to_c (const Opaque_tao_v1_var_class*, CPP_tao_v1_var&);
extern "C" void tao_v1_var_to_f (const CPP_tao_v1_var&, Opaque_tao_v1_var_class*);

bool operator== (const CPP_tao_v1_var&, const CPP_tao_v1_var&);


//--------------------------------------------------------------------
// CPP_tao_var_array

class Opaque_tao_var_array_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_var_array {
public:
  CPP_tao_var* v;

  CPP_tao_var_array() :
    v(NULL)
    {}

  ~CPP_tao_var_array() {
  }

};   // End Class

extern "C" void tao_var_array_to_c (const Opaque_tao_var_array_class*, CPP_tao_var_array&);
extern "C" void tao_var_array_to_f (const CPP_tao_var_array&, Opaque_tao_var_array_class*);

bool operator== (const CPP_tao_var_array&, const CPP_tao_var_array&);


//--------------------------------------------------------------------
// CPP_tao_v1_var_array

class Opaque_tao_v1_var_array_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_v1_var_array {
public:
  CPP_tao_v1_var* v1;

  CPP_tao_v1_var_array() :
    v1(NULL)
    {}

  ~CPP_tao_v1_var_array() {
  }

};   // End Class

extern "C" void tao_v1_var_array_to_c (const Opaque_tao_v1_var_array_class*, CPP_tao_v1_var_array&);
extern "C" void tao_v1_var_array_to_f (const CPP_tao_v1_var_array&, Opaque_tao_v1_var_array_class*);

bool operator== (const CPP_tao_v1_var_array&, const CPP_tao_v1_var_array&);


//--------------------------------------------------------------------
// CPP_tao_building_wall_point

class Opaque_tao_building_wall_point_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_building_wall_point {
public:
  Real z;
  Real x;
  Real radius;
  Real z_center;
  Real x_center;

  CPP_tao_building_wall_point() :
    z(0.0),
    x(0.0),
    radius(0.0),
    z_center(0.0),
    x_center(0.0)
    {}

  ~CPP_tao_building_wall_point() {
  }

};   // End Class

extern "C" void tao_building_wall_point_to_c (const Opaque_tao_building_wall_point_class*, CPP_tao_building_wall_point&);
extern "C" void tao_building_wall_point_to_f (const CPP_tao_building_wall_point&, Opaque_tao_building_wall_point_class*);

bool operator== (const CPP_tao_building_wall_point&, const CPP_tao_building_wall_point&);


//--------------------------------------------------------------------
// CPP_tao_building_wall_section

class Opaque_tao_building_wall_section_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_building_wall_section {
public:
  string constraint;
  CPP_tao_building_wall_point_ARRAY point;

  CPP_tao_building_wall_section() :
    constraint(),
    point(CPP_tao_building_wall_point_ARRAY(CPP_tao_building_wall_point(), 0))
    {}

  ~CPP_tao_building_wall_section() {
  }

};   // End Class

extern "C" void tao_building_wall_section_to_c (const Opaque_tao_building_wall_section_class*, CPP_tao_building_wall_section&);
extern "C" void tao_building_wall_section_to_f (const CPP_tao_building_wall_section&, Opaque_tao_building_wall_section_class*);

bool operator== (const CPP_tao_building_wall_section&, const CPP_tao_building_wall_section&);


//--------------------------------------------------------------------
// CPP_tao_building_wall

class Opaque_tao_building_wall_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_building_wall {
public:
  CPP_tao_building_wall_section_ARRAY section;

  CPP_tao_building_wall() :
    section(CPP_tao_building_wall_section_ARRAY(CPP_tao_building_wall_section(), 0))
    {}

  ~CPP_tao_building_wall() {
  }

};   // End Class

extern "C" void tao_building_wall_to_c (const Opaque_tao_building_wall_class*, CPP_tao_building_wall&);
extern "C" void tao_building_wall_to_f (const CPP_tao_building_wall&, Opaque_tao_building_wall_class*);

bool operator== (const CPP_tao_building_wall&, const CPP_tao_building_wall&);


//--------------------------------------------------------------------
// CPP_tao_global

class Opaque_tao_global_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_global {
public:
  Real y_axis_plot_dmin;
  Real lm_opt_deriv_reinit;
  Real de_lm_step_ratio;
  Real de_var_to_population_factor;
  Real lmdif_eps;
  Real svd_cutoff;
  Real unstable_penalty;
  Real merit_stop_value;
  Real random_sigma_cutoff;
  Real delta_e_chrom;
  Int n_opti_cycles;
  Int n_opti_loops;
  Int phase_units;
  Int bunch_to_plot;
  Int random_seed;
  Int n_top10;
  string random_engine;
  string random_gauss_converter;
  string track_type;
  string prompt_string;
  string prompt_color;
  string optimizer;
  string print_command;
  string var_out_file;
  Bool initialized;
  Bool opt_with_ref;
  Bool opt_with_base;
  Bool label_lattice_elements;
  Bool label_keys;
  Bool derivative_recalc;
  Bool derivative_uses_design;
  Bool init_plot_needed;
  Bool orm_analysis;
  Bool plot_on;
  Bool lattice_calc_on;
  Bool svd_retreat_on_merit_increase;
  Bool stop_on_error;
  Bool command_file_print_on;
  Bool box_plots;
  Bool beam_timer_on;
  Bool var_limits_on;
  Bool only_limit_opt_vars;
  Bool optimizer_var_limit_warn;
  Bool rf_on;
  Bool draw_curve_off_scale_warn;
  Bool wait_for_cr_in_single_mode;
  Bool disable_smooth_line_calc;
  Bool debug_on;
  Bool single_step;
  Bool optimizer_allow_user_abort;
  Bool quiet;

  CPP_tao_global() :
    y_axis_plot_dmin(1e-4),
    lm_opt_deriv_reinit(-1),
    de_lm_step_ratio(1),
    de_var_to_population_factor(0.0),
    lmdif_eps(1e-12),
    svd_cutoff(1e-5),
    unstable_penalty(1e-3),
    merit_stop_value(-1),
    random_sigma_cutoff(-1),
    delta_e_chrom(0.0),
    n_opti_cycles(20),
    n_opti_loops(1),
    phase_units(Bmad::RADIANS),
    bunch_to_plot(1),
    random_seed(0),
    n_top10(10),
    random_engine(),
    random_gauss_converter(),
    track_type(),
    prompt_string(),
    prompt_color(),
    optimizer(),
    print_command(),
    var_out_file(),
    initialized(false),
    opt_with_ref(false),
    opt_with_base(false),
    label_lattice_elements(true),
    label_keys(true),
    derivative_recalc(true),
    derivative_uses_design(false),
    init_plot_needed(true),
    orm_analysis(false),
    plot_on(true),
    lattice_calc_on(true),
    svd_retreat_on_merit_increase(true),
    stop_on_error(true),
    command_file_print_on(true),
    box_plots(false),
    beam_timer_on(false),
    var_limits_on(true),
    only_limit_opt_vars(false),
    optimizer_var_limit_warn(true),
    rf_on(false),
    draw_curve_off_scale_warn(true),
    wait_for_cr_in_single_mode(false),
    disable_smooth_line_calc(false),
    debug_on(false),
    single_step(false),
    optimizer_allow_user_abort(true),
    quiet(false)
    {}

  ~CPP_tao_global() {
  }

};   // End Class

extern "C" void tao_global_to_c (const Opaque_tao_global_class*, CPP_tao_global&);
extern "C" void tao_global_to_f (const CPP_tao_global&, Opaque_tao_global_class*);

bool operator== (const CPP_tao_global&, const CPP_tao_global&);


//--------------------------------------------------------------------
// CPP_tao_alias

class Opaque_tao_alias_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_alias {
public:
  string name;
  string expanded_str;

  CPP_tao_alias() :
    name(),
    expanded_str()
    {}

  ~CPP_tao_alias() {
  }

};   // End Class

extern "C" void tao_alias_to_c (const Opaque_tao_alias_class*, CPP_tao_alias&);
extern "C" void tao_alias_to_f (const CPP_tao_alias&, Opaque_tao_alias_class*);

bool operator== (const CPP_tao_alias&, const CPP_tao_alias&);


//--------------------------------------------------------------------
// CPP_tao_command_file

class Opaque_tao_command_file_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_command_file {
public:
  string name;
  Int ix_unit;
  String_ARRAY cmd_arg;
  Bool paused;
  Int n_line;

  CPP_tao_command_file() :
    name(),
    ix_unit(0),
    cmd_arg(String_ARRAY(string(), 9)),
    paused(false),
    n_line(0)
    {}

  ~CPP_tao_command_file() {
  }

};   // End Class

extern "C" void tao_command_file_to_c (const Opaque_tao_command_file_class*, CPP_tao_command_file&);
extern "C" void tao_command_file_to_f (const CPP_tao_command_file&, Opaque_tao_command_file_class*);

bool operator== (const CPP_tao_command_file&, const CPP_tao_command_file&);


//--------------------------------------------------------------------
// CPP_tao_common

class Opaque_tao_common_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_common {
public:
  CPP_tao_alias_ARRAY alias;
  CPP_tao_alias_ARRAY key;
  CPP_tao_universe* u_working;
  CPP_tao_command_file_ARRAY cmd_file;
  Real_MATRIX covar;
  Real_MATRIX alpha;
  Real dummy_target;
  Int ix_ref_taylor;
  Int ix_ele_taylor;
  Int n_alias;
  Int cmd_file_level;
  Int ix_key_bank;
  Int n_universes;
  Int default_universe;
  Int default_branch;
  Int ix_history;
  Int n_history;
  Bool cmd_file_paused;
  Bool use_cmd_here;
  Bool multi_commands_here;
  Bool cmd_from_cmd_file;
  Bool use_saved_beam_in_tracking;
  Bool single_mode;
  Bool combine_consecutive_elements_of_like_name;
  Bool common_lattice;
  Bool init_beam;
  Bool init_var;
  Bool init_read_lat_info;
  Bool init_data;
  Bool parse_cmd_args;
  Bool optimizer_running;
  Bool have_datums_using_expressions;
  Bool noplot_arg_set;
  Bool init_tao_file_arg_set;
  Bool log_startup;
  Bool print_to_terminal;
  string cmd;
  string init_name;
  string lat_file;
  string init_tao_file;
  string init_tao_file_path;
  string beam_file;
  string beam_all_file;
  string beam0_file;
  string data_file;
  string plot_file;
  string startup_file;
  string var_file;
  string building_wall_file;
  string hook_init_file;
  string plot_geometry;
  string single_mode_buffer;
  string unique_name_suffix;
  String_ARRAY valid_plot_who;

  CPP_tao_common() :
    alias(CPP_tao_alias_ARRAY(CPP_tao_alias(), 200)),
    key(CPP_tao_alias_ARRAY(CPP_tao_alias(), 100)),
    u_working(NULL),
    cmd_file(CPP_tao_command_file_ARRAY(CPP_tao_command_file(), 0)),
    covar(Real_ARRAY(0.0, 0), 0),
    alpha(Real_ARRAY(0.0, 0), 0),
    dummy_target(0.0),
    ix_ref_taylor(0),
    ix_ele_taylor(0),
    n_alias(0),
    cmd_file_level(0),
    ix_key_bank(0),
    n_universes(1),
    default_universe(1),
    default_branch(0),
    ix_history(0),
    n_history(0),
    cmd_file_paused(false),
    use_cmd_here(false),
    multi_commands_here(false),
    cmd_from_cmd_file(false),
    use_saved_beam_in_tracking(false),
    single_mode(false),
    combine_consecutive_elements_of_like_name(false),
    common_lattice(false),
    init_beam(true),
    init_var(true),
    init_read_lat_info(true),
    init_data(true),
    parse_cmd_args(true),
    optimizer_running(false),
    have_datums_using_expressions(false),
    noplot_arg_set(false),
    init_tao_file_arg_set(false),
    log_startup(false),
    print_to_terminal(true),
    cmd(),
    init_name(),
    lat_file(),
    init_tao_file(),
    init_tao_file_path(),
    beam_file(),
    beam_all_file(),
    beam0_file(),
    data_file(),
    plot_file(),
    startup_file(),
    var_file(),
    building_wall_file(),
    hook_init_file(),
    plot_geometry(),
    single_mode_buffer(),
    unique_name_suffix(),
    valid_plot_who(String_ARRAY(string(), 10))
    {}

  ~CPP_tao_common() {
  }

};   // End Class

extern "C" void tao_common_to_c (const Opaque_tao_common_class*, CPP_tao_common&);
extern "C" void tao_common_to_f (const CPP_tao_common&, Opaque_tao_common_class*);

bool operator== (const CPP_tao_common&, const CPP_tao_common&);


//--------------------------------------------------------------------
// CPP_tao_lat_mode

class Opaque_tao_lat_mode_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_lat_mode {
public:
  Real chrom;
  Real growth_rate;

  CPP_tao_lat_mode() :
    chrom(0.0),
    growth_rate(0.0)
    {}

  ~CPP_tao_lat_mode() {
  }

};   // End Class

extern "C" void tao_lat_mode_to_c (const Opaque_tao_lat_mode_class*, CPP_tao_lat_mode&);
extern "C" void tao_lat_mode_to_f (const CPP_tao_lat_mode&, Opaque_tao_lat_mode_class*);

bool operator== (const CPP_tao_lat_mode&, const CPP_tao_lat_mode&);


//--------------------------------------------------------------------
// CPP_tao_sigma_mat

class Opaque_tao_sigma_mat_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_sigma_mat {
public:
  Real_MATRIX sigma;

  CPP_tao_sigma_mat() :
    sigma(Real_ARRAY(0.0, 6), 6)
    {}

  ~CPP_tao_sigma_mat() {
  }

};   // End Class

extern "C" void tao_sigma_mat_to_c (const Opaque_tao_sigma_mat_class*, CPP_tao_sigma_mat&);
extern "C" void tao_sigma_mat_to_f (const CPP_tao_sigma_mat&, Opaque_tao_sigma_mat_class*);

bool operator== (const CPP_tao_sigma_mat&, const CPP_tao_sigma_mat&);


//--------------------------------------------------------------------
// CPP_tao_lattice_branch

class Opaque_tao_lattice_branch_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_lattice_branch {
public:
  CPP_bunch_params_ARRAY bunch_params;
  CPP_tao_sigma_mat_ARRAY linear;
  CPP_coord_ARRAY orbit;
  CPP_coord orb0;
  CPP_lat high_e_lat;
  CPP_lat low_e_lat;
  Int track_state;
  Bool has_open_match_element;
  CPP_normal_modes modes;
  CPP_rad_int_all_ele rad_int;
  CPP_tao_lat_mode a;
  CPP_tao_lat_mode b;
  Int ix_rad_int_cache;
  CPP_normal_modes modes_rf_on;
  CPP_rad_int_all_ele rad_int_rf_on;

  CPP_tao_lattice_branch() :
    bunch_params(CPP_bunch_params_ARRAY(CPP_bunch_params(), 0)),
    linear(CPP_tao_sigma_mat_ARRAY(CPP_tao_sigma_mat(), 0)),
    orbit(CPP_coord_ARRAY(CPP_coord(), 0)),
    orb0(),
    high_e_lat(),
    low_e_lat(),
    track_state(0),
    has_open_match_element(false),
    modes(),
    rad_int(),
    a(),
    b(),
    ix_rad_int_cache(0),
    modes_rf_on(),
    rad_int_rf_on()
    {}

  ~CPP_tao_lattice_branch() {
  }

};   // End Class

extern "C" void tao_lattice_branch_to_c (const Opaque_tao_lattice_branch_class*, CPP_tao_lattice_branch&);
extern "C" void tao_lattice_branch_to_f (const CPP_tao_lattice_branch&, Opaque_tao_lattice_branch_class*);

bool operator== (const CPP_tao_lattice_branch&, const CPP_tao_lattice_branch&);


//--------------------------------------------------------------------
// CPP_tao_lattice

class Opaque_tao_lattice_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_lattice {
public:
  CPP_lat lat;
  CPP_tao_lattice_branch_ARRAY tao_branch;

  CPP_tao_lattice() :
    lat(),
    tao_branch(CPP_tao_lattice_branch_ARRAY(CPP_tao_lattice_branch(), 0))
    {}

  ~CPP_tao_lattice() {
  }

};   // End Class

extern "C" void tao_lattice_to_c (const Opaque_tao_lattice_class*, CPP_tao_lattice&);
extern "C" void tao_lattice_to_f (const CPP_tao_lattice&, Opaque_tao_lattice_class*);

bool operator== (const CPP_tao_lattice&, const CPP_tao_lattice&);


//--------------------------------------------------------------------
// CPP_tao_element

class Opaque_tao_element_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_element {
public:
  CPP_beam beam;
  Bool save_beam;

  CPP_tao_element() :
    beam(),
    save_beam(false)
    {}

  ~CPP_tao_element() {
  }

};   // End Class

extern "C" void tao_element_to_c (const Opaque_tao_element_class*, CPP_tao_element&);
extern "C" void tao_element_to_f (const CPP_tao_element&, Opaque_tao_element_class*);

bool operator== (const CPP_tao_element&, const CPP_tao_element&);


//--------------------------------------------------------------------
// CPP_tao_ping_scale

class Opaque_tao_ping_scale_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_ping_scale {
public:
  Real a_mode_meas;
  Real a_mode_ref;
  Real b_mode_meas;
  Real b_mode_ref;

  CPP_tao_ping_scale() :
    a_mode_meas(1),
    a_mode_ref(1),
    b_mode_meas(1),
    b_mode_ref(1)
    {}

  ~CPP_tao_ping_scale() {
  }

};   // End Class

extern "C" void tao_ping_scale_to_c (const Opaque_tao_ping_scale_class*, CPP_tao_ping_scale&);
extern "C" void tao_ping_scale_to_f (const CPP_tao_ping_scale&, Opaque_tao_ping_scale_class*);

bool operator== (const CPP_tao_ping_scale&, const CPP_tao_ping_scale&);


//--------------------------------------------------------------------
// CPP_tao_universe_branch

class Opaque_tao_universe_branch_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_universe_branch {
public:
  CPP_tao_element_ARRAY ele;
  string track_start;
  string track_end;
  Int ix_track_start;
  Int ix_track_end;

  CPP_tao_universe_branch() :
    ele(CPP_tao_element_ARRAY(CPP_tao_element(), 0)),
    track_start(),
    track_end(),
    ix_track_start(0),
    ix_track_end(0)
    {}

  ~CPP_tao_universe_branch() {
  }

};   // End Class

extern "C" void tao_universe_branch_to_c (const Opaque_tao_universe_branch_class*, CPP_tao_universe_branch&);
extern "C" void tao_universe_branch_to_f (const CPP_tao_universe_branch&, Opaque_tao_universe_branch_class*);

bool operator== (const CPP_tao_universe_branch&, const CPP_tao_universe_branch&);


//--------------------------------------------------------------------
// CPP_tao_beam

class Opaque_tao_beam_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_beam {
public:
  CPP_beam_init beam_init;
  CPP_beam start;
  Bool init_beam0;
  string beam_all_file;
  string beam0_file;
  string saved_at;

  CPP_tao_beam() :
    beam_init(),
    start(),
    init_beam0(false),
    beam_all_file(),
    beam0_file(),
    saved_at()
    {}

  ~CPP_tao_beam() {
  }

};   // End Class

extern "C" void tao_beam_to_c (const Opaque_tao_beam_class*, CPP_tao_beam&);
extern "C" void tao_beam_to_f (const CPP_tao_beam&, Opaque_tao_beam_class*);

bool operator== (const CPP_tao_beam&, const CPP_tao_beam&);


//--------------------------------------------------------------------
// CPP_tao_universe_calc

class Opaque_tao_universe_calc_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_universe_calc {
public:
  Bool rad_int_for_data;
  Bool rad_int_for_plotting;
  Bool chrom_for_data;
  Bool chrom_for_plotting;
  Bool beam_sigma_for_data;
  Bool beam_sigma_for_plotting;
  Bool dynamic_aperture;
  Bool one_turn_map;
  Bool lattice;
  Bool mat6;
  Bool track;

  CPP_tao_universe_calc() :
    rad_int_for_data(false),
    rad_int_for_plotting(false),
    chrom_for_data(false),
    chrom_for_plotting(false),
    beam_sigma_for_data(false),
    beam_sigma_for_plotting(false),
    dynamic_aperture(false),
    one_turn_map(false),
    lattice(false),
    mat6(true),
    track(true)
    {}

  ~CPP_tao_universe_calc() {
  }

};   // End Class

extern "C" void tao_universe_calc_to_c (const Opaque_tao_universe_calc_class*, CPP_tao_universe_calc&);
extern "C" void tao_universe_calc_to_f (const CPP_tao_universe_calc&, Opaque_tao_universe_calc_class*);

bool operator== (const CPP_tao_universe_calc&, const CPP_tao_universe_calc&);


//--------------------------------------------------------------------
// CPP_tao_mpi

class Opaque_tao_mpi_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_mpi {
public:
  Bool on;
  Bool master;
  Int rank;
  Int max_rank;
  string host_name;

  CPP_tao_mpi() :
    on(false),
    master(true),
    rank(0),
    max_rank(0),
    host_name()
    {}

  ~CPP_tao_mpi() {
  }

};   // End Class

extern "C" void tao_mpi_to_c (const Opaque_tao_mpi_class*, CPP_tao_mpi&);
extern "C" void tao_mpi_to_f (const CPP_tao_mpi&, Opaque_tao_mpi_class*);

bool operator== (const CPP_tao_mpi&, const CPP_tao_mpi&);


//--------------------------------------------------------------------
// CPP_tao_dynamic_aperture

class Opaque_tao_dynamic_aperture_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_dynamic_aperture {
public:
  CPP_aperture_scan_ARRAY scan;
  Real_ARRAY pz;

  CPP_tao_dynamic_aperture() :
    scan(CPP_aperture_scan_ARRAY(CPP_aperture_scan(), 0)),
    pz(0.0, 0)
    {}

  ~CPP_tao_dynamic_aperture() {
  }

};   // End Class

extern "C" void tao_dynamic_aperture_to_c (const Opaque_tao_dynamic_aperture_class*, CPP_tao_dynamic_aperture&);
extern "C" void tao_dynamic_aperture_to_f (const CPP_tao_dynamic_aperture&, Opaque_tao_dynamic_aperture_class*);

bool operator== (const CPP_tao_dynamic_aperture&, const CPP_tao_dynamic_aperture&);


//--------------------------------------------------------------------
// CPP_tao_universe

class Opaque_tao_universe_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_universe {
public:
  CPP_tao_universe* common;
  CPP_tao_lattice* model;
  CPP_tao_lattice* design;
  CPP_tao_lattice* base;
  CPP_tao_beam beam;
  CPP_tao_dynamic_aperture dynamic_aperture;
  CPP_tao_universe_branch_ARRAY uni_branch;
  CPP_tao_d2_data_ARRAY d2_data;
  CPP_tao_data_ARRAY data;
  CPP_tao_ping_scale ping_scale;
  CPP_lat scratch_lat;
  CPP_tao_universe_calc calc;
  Real_MATRIX dmodel_dvar;
  Int ix_uni;
  Int n_d2_data_used;
  Int n_data_used;
  Bool reverse_tracking;
  Bool is_on;
  Bool picked_uni;

  CPP_tao_universe() :
    common(NULL),
    model(NULL),
    design(NULL),
    base(NULL),
    beam(),
    dynamic_aperture(),
    uni_branch(CPP_tao_universe_branch_ARRAY(CPP_tao_universe_branch(), 0)),
    d2_data(CPP_tao_d2_data_ARRAY(CPP_tao_d2_data(), 0)),
    data(CPP_tao_data_ARRAY(CPP_tao_data(), 0)),
    ping_scale(),
    scratch_lat(),
    calc(),
    dmodel_dvar(Real_ARRAY(0.0, 0), 0),
    ix_uni(0),
    n_d2_data_used(0),
    n_data_used(0),
    reverse_tracking(false),
    is_on(false),
    picked_uni(false)
    {}

  ~CPP_tao_universe() {
  }

};   // End Class

extern "C" void tao_universe_to_c (const Opaque_tao_universe_class*, CPP_tao_universe&);
extern "C" void tao_universe_to_f (const CPP_tao_universe&, Opaque_tao_universe_class*);

bool operator== (const CPP_tao_universe&, const CPP_tao_universe&);


//--------------------------------------------------------------------
// CPP_tao_super_universe

class Opaque_tao_super_universe_class {};  // Opaque class for pointers to corresponding fortran structs.

class CPP_tao_super_universe {
public:
  CPP_tao_global global;
  CPP_tao_common com;
  CPP_tao_plot_page plot_page;
  CPP_tao_v1_var_ARRAY v1_var;
  CPP_tao_var_ARRAY var;
  CPP_tao_universe_ARRAY u;
  CPP_tao_mpi mpi;
  Int_ARRAY key;
  CPP_tao_building_wall building_wall;
  CPP_tao_wave wave;
  Int n_var_used;
  Int n_v1_var_used;
  CPP_tao_cmd_history_ARRAY history;

  CPP_tao_super_universe() :
    global(),
    com(),
    plot_page(),
    v1_var(CPP_tao_v1_var_ARRAY(CPP_tao_v1_var(), 0)),
    var(CPP_tao_var_ARRAY(CPP_tao_var(), 0)),
    u(CPP_tao_universe_ARRAY(CPP_tao_universe(), 0)),
    mpi(),
    key(0, 0),
    building_wall(),
    wave(),
    n_var_used(0),
    n_v1_var_used(0),
    history(CPP_tao_cmd_history_ARRAY(CPP_tao_cmd_history(), 1000))
    {}

  ~CPP_tao_super_universe() {
  }

};   // End Class

extern "C" void tao_super_universe_to_c (const Opaque_tao_super_universe_class*, CPP_tao_super_universe&);
extern "C" void tao_super_universe_to_f (const CPP_tao_super_universe&, Opaque_tao_super_universe_class*);

bool operator== (const CPP_tao_super_universe&, const CPP_tao_super_universe&);


//--------------------------------------------------------------------

#define CPP_TAO_CLASSES
#endif