package run;

import java.util.*;

import java.io.*;

import run.readers.FembicReader;

import uka.karmi.rmi.RemoteException;

import jp.sync.*;

import jp.lang.*;



public class SmackCluster_instance_impl extends jp.lang.RemoteObject_instance_impl
  implements SmackCluster_instance_intf
{

  private int number_of_elements;

  /** Remote variable access: get SmackCluster.number_of_elements */
  public final int run_SmackCluster_number_of_elements_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_elements;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.number_of_elements */
  public final int run_SmackCluster_number_of_elements_set_(int _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_elements = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_elements */
  public final int run_SmackCluster_number_of_elements_inc_(int _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        int _before_ = this.number_of_elements;
        this.number_of_elements += _value_;
        return _before_;
      } else {
        return this.number_of_elements += _value_;
      }
    } finally {
      _dec();
    }
  }

  private int number_of_trackers;

  /** Remote variable access: get SmackCluster.number_of_trackers */
  public final int run_SmackCluster_number_of_trackers_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_trackers;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.number_of_trackers */
  public final int run_SmackCluster_number_of_trackers_set_(int _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_trackers = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_trackers */
  public final int run_SmackCluster_number_of_trackers_inc_(int _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        int _before_ = this.number_of_trackers;
        this.number_of_trackers += _value_;
        return _before_;
      } else {
        return this.number_of_trackers += _value_;
      }
    } finally {
      _dec();
    }
  }

  private int number_of_nodes;

  /** Remote variable access: get SmackCluster.number_of_nodes */
  public final int run_SmackCluster_number_of_nodes_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_nodes;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.number_of_nodes */
  public final int run_SmackCluster_number_of_nodes_set_(int _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_nodes = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_nodes */
  public final int run_SmackCluster_number_of_nodes_inc_(int _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        int _before_ = this.number_of_nodes;
        this.number_of_nodes += _value_;
        return _before_;
      } else {
        return this.number_of_nodes += _value_;
      }
    } finally {
      _dec();
    }
  }

  private int number_of_materials;

  /** Remote variable access: get SmackCluster.number_of_materials */
  public final int run_SmackCluster_number_of_materials_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_materials;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.number_of_materials */
  public final int run_SmackCluster_number_of_materials_set_(int _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_materials = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_materials */
  public final int run_SmackCluster_number_of_materials_inc_(int _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        int _before_ = this.number_of_materials;
        this.number_of_materials += _value_;
        return _before_;
      } else {
        return this.number_of_materials += _value_;
      }
    } finally {
      _dec();
    }
  }

  private int number_of_controls;

  /** Remote variable access: get SmackCluster.number_of_controls */
  public final int run_SmackCluster_number_of_controls_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_controls;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.number_of_controls */
  public final int run_SmackCluster_number_of_controls_set_(int _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_controls = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_controls */
  public final int run_SmackCluster_number_of_controls_inc_(int _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        int _before_ = this.number_of_controls;
        this.number_of_controls += _value_;
        return _before_;
      } else {
        return this.number_of_controls += _value_;
      }
    } finally {
      _dec();
    }
  }

  private int number_of_constraints;

  /** Remote variable access: get SmackCluster.number_of_constraints */
  public final int run_SmackCluster_number_of_constraints_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_constraints;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.number_of_constraints */
  public final int run_SmackCluster_number_of_constraints_set_(int _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_constraints = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_constraints */
  public final int run_SmackCluster_number_of_constraints_inc_(int _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        int _before_ = this.number_of_constraints;
        this.number_of_constraints += _value_;
        return _before_;
      } else {
        return this.number_of_constraints += _value_;
      }
    } finally {
      _dec();
    }
  }

  private int number_of_loads;

  /** Remote variable access: get SmackCluster.number_of_loads */
  public final int run_SmackCluster_number_of_loads_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_loads;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.number_of_loads */
  public final int run_SmackCluster_number_of_loads_set_(int _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.number_of_loads = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_loads */
  public final int run_SmackCluster_number_of_loads_inc_(int _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        int _before_ = this.number_of_loads;
        this.number_of_loads += _value_;
        return _before_;
      } else {
        return this.number_of_loads += _value_;
      }
    } finally {
      _dec();
    }
  }

  private run.RplVector constraintlist;

  /** Remote variable access: get SmackCluster.constraintlist */
  public final run.RplVector run_SmackCluster_constraintlist_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.constraintlist;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.constraintlist */
  public final run.RplVector run_SmackCluster_constraintlist_set_(run.RplVector _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.constraintlist = _value_;
    } finally {
      _dec();
    }
  }

  private run.RplVector loadlist;

  /** Remote variable access: get SmackCluster.loadlist */
  public final run.RplVector run_SmackCluster_loadlist_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.loadlist;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.loadlist */
  public final run.RplVector run_SmackCluster_loadlist_set_(run.RplVector _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.loadlist = _value_;
    } finally {
      _dec();
    }
  }

  private run.RplVector nodelist;

  /** Remote variable access: get SmackCluster.nodelist */
  public final run.RplVector run_SmackCluster_nodelist_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.nodelist;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.nodelist */
  public final run.RplVector run_SmackCluster_nodelist_set_(run.RplVector _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.nodelist = _value_;
    } finally {
      _dec();
    }
  }

  private run.RplVector elementlist;

  /** Remote variable access: get SmackCluster.elementlist */
  public final run.RplVector run_SmackCluster_elementlist_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.elementlist;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.elementlist */
  public final run.RplVector run_SmackCluster_elementlist_set_(run.RplVector _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.elementlist = _value_;
    } finally {
      _dec();
    }
  }

  private run.RplVector trackerlist;

  /** Remote variable access: get SmackCluster.trackerlist */
  public final run.RplVector run_SmackCluster_trackerlist_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.trackerlist;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.trackerlist */
  public final run.RplVector run_SmackCluster_trackerlist_set_(run.RplVector _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.trackerlist = _value_;
    } finally {
      _dec();
    }
  }

  private run.RplVector materiallist;

  /** Remote variable access: get SmackCluster.materiallist */
  public final run.RplVector run_SmackCluster_materiallist_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.materiallist;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.materiallist */
  public final run.RplVector run_SmackCluster_materiallist_set_(run.RplVector _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.materiallist = _value_;
    } finally {
      _dec();
    }
  }

  private volatile double time;

  /** Remote variable access: get SmackCluster.time */
  public final double run_SmackCluster_time_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.time;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.time */
  public final double run_SmackCluster_time_set_(double _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.time = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.time */
  public final double run_SmackCluster_time_inc_(double _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        double _before_ = this.time;
        this.time += _value_;
        return _before_;
      } else {
        return this.time += _value_;
      }
    } finally {
      _dec();
    }
  }

  private volatile double ttemp;

  /** Remote variable access: get SmackCluster.ttemp */
  public final double run_SmackCluster_ttemp_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.ttemp;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.ttemp */
  public final double run_SmackCluster_ttemp_set_(double _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.ttemp = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.ttemp */
  public final double run_SmackCluster_ttemp_inc_(double _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        double _before_ = this.ttemp;
        this.ttemp += _value_;
        return _before_;
      } else {
        return this.ttemp += _value_;
      }
    } finally {
      _dec();
    }
  }

  private volatile double exported_ttemp;

  /** Remote variable access: get SmackCluster.exported_ttemp */
  public final double run_SmackCluster_exported_ttemp_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.exported_ttemp;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.exported_ttemp */
  public final double run_SmackCluster_exported_ttemp_set_(double _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.exported_ttemp = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.exported_ttemp */
  public final double run_SmackCluster_exported_ttemp_inc_(double _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        double _before_ = this.exported_ttemp;
        this.exported_ttemp += _value_;
        return _before_;
      } else {
        return this.exported_ttemp += _value_;
      }
    } finally {
      _dec();
    }
  }

  private int i;

  /** Remote variable access: get SmackCluster.i */
  public final int run_SmackCluster_i_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.i;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.i */
  public final int run_SmackCluster_i_set_(int _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.i = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.i */
  public final int run_SmackCluster_i_inc_(int _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        int _before_ = this.i;
        this.i += _value_;
        return _before_;
      } else {
        return this.i += _value_;
      }
    } finally {
      _dec();
    }
  }

  private run.Controlset controlset;

  /** Remote variable access: get SmackCluster.controlset */
  public final run.Controlset run_SmackCluster_controlset_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.controlset;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.controlset */
  public final run.Controlset run_SmackCluster_controlset_set_(run.Controlset _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.controlset = _value_;
    } finally {
      _dec();
    }
  }

  private run.Element temporary_element;

  /** Remote variable access: get SmackCluster.temporary_element */
  public final run.Element run_SmackCluster_temporary_element_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.temporary_element;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.temporary_element */
  public final run.Element run_SmackCluster_temporary_element_set_(run.Element _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.temporary_element = _value_;
    } finally {
      _dec();
    }
  }

  private run.Tracker temporary_tracker;

  /** Remote variable access: get SmackCluster.temporary_tracker */
  public final run.Tracker run_SmackCluster_temporary_tracker_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.temporary_tracker;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.temporary_tracker */
  public final run.Tracker run_SmackCluster_temporary_tracker_set_(run.Tracker _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.temporary_tracker = _value_;
    } finally {
      _dec();
    }
  }

  private run.Constraint temporary_constraint;

  /** Remote variable access: get SmackCluster.temporary_constraint */
  public final run.Constraint run_SmackCluster_temporary_constraint_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.temporary_constraint;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.temporary_constraint */
  public final run.Constraint run_SmackCluster_temporary_constraint_set_(run.Constraint _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.temporary_constraint = _value_;
    } finally {
      _dec();
    }
  }

  private run.Node temporary_node;

  /** Remote variable access: get SmackCluster.temporary_node */
  public final run.Node run_SmackCluster_temporary_node_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.temporary_node;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.temporary_node */
  public final run.Node run_SmackCluster_temporary_node_set_(run.Node _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.temporary_node = _value_;
    } finally {
      _dec();
    }
  }

  private run.Writer resultwriter;

  /** Remote variable access: get SmackCluster.resultwriter */
  public final run.Writer run_SmackCluster_resultwriter_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.resultwriter;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.resultwriter */
  public final run.Writer run_SmackCluster_resultwriter_set_(run.Writer _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.resultwriter = _value_;
    } finally {
      _dec();
    }
  }

  private run.TrackWriter trackwriter;

  /** Remote variable access: get SmackCluster.trackwriter */
  public final run.TrackWriter run_SmackCluster_trackwriter_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.trackwriter;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.trackwriter */
  public final run.TrackWriter run_SmackCluster_trackwriter_set_(run.TrackWriter _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.trackwriter = _value_;
    } finally {
      _dec();
    }
  }

  private java.lang.String filename;

  /** Remote variable access: get SmackCluster.filename */
  public final java.lang.String run_SmackCluster_filename_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.filename;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.filename */
  public final java.lang.String run_SmackCluster_filename_set_(java.lang.String _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.filename = _value_;
    } finally {
      _dec();
    }
  }

  private double timestep;

  /** Remote variable access: get SmackCluster.timestep */
  public final double run_SmackCluster_timestep_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.timestep;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.timestep */
  public final double run_SmackCluster_timestep_set_(double _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.timestep = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.timestep */
  public final double run_SmackCluster_timestep_inc_(double _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        double _before_ = this.timestep;
        this.timestep += _value_;
        return _before_;
      } else {
        return this.timestep += _value_;
      }
    } finally {
      _dec();
    }
  }

  private boolean failure_is_set = false;

  /** Remote variable access: get SmackCluster.failure_is_set */
  public final boolean run_SmackCluster_failure_is_set_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.failure_is_set;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.failure_is_set */
  public final boolean run_SmackCluster_failure_is_set_set_(boolean _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.failure_is_set = _value_;
    } finally {
      _dec();
    }
  }

  private boolean autostep;

  /** Remote variable access: get SmackCluster.autostep */
  public final boolean run_SmackCluster_autostep_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.autostep;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.autostep */
  public final boolean run_SmackCluster_autostep_set_(boolean _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.autostep = _value_;
    } finally {
      _dec();
    }
  }

  private int nr_of_CPUs;

  /** Remote variable access: get SmackCluster.nr_of_CPUs */
  public final int run_SmackCluster_nr_of_CPUs_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.nr_of_CPUs;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.nr_of_CPUs */
  public final int run_SmackCluster_nr_of_CPUs_set_(int _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.nr_of_CPUs = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.nr_of_CPUs */
  public final int run_SmackCluster_nr_of_CPUs_inc_(int _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        int _before_ = this.nr_of_CPUs;
        this.nr_of_CPUs += _value_;
        return _before_;
      } else {
        return this.nr_of_CPUs += _value_;
      }
    } finally {
      _dec();
    }
  }

  private int client_nr;

  /** Remote variable access: get SmackCluster.client_nr */
  public final int run_SmackCluster_client_nr_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.client_nr;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.client_nr */
  public final int run_SmackCluster_client_nr_set_(int _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.client_nr = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.client_nr */
  public final int run_SmackCluster_client_nr_inc_(int _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        int _before_ = this.client_nr;
        this.client_nr += _value_;
        return _before_;
      } else {
        return this.client_nr += _value_;
      }
    } finally {
      _dec();
    }
  }

  private run.SmackCluster[] cluster_nodes;

  /** Remote variable access: get SmackCluster.cluster_nodes */
  public final run.SmackCluster[] run_SmackCluster_cluster_nodes_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.cluster_nodes;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.cluster_nodes */
  public final run.SmackCluster[] run_SmackCluster_cluster_nodes_set_(run.SmackCluster[] _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.cluster_nodes = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: get SmackCluster.cluster_nodes[p0] */
  public final run.SmackCluster run_SmackCluster_cluster_nodes_get_(int p0) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.cluster_nodes[p0];
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.cluster_nodes[p0] */
  public final run.SmackCluster run_SmackCluster_cluster_nodes_set_(int p0, run.SmackCluster _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.cluster_nodes[p0] = _value_;
    } finally {
      _dec();
    }
  }

  private int[] nodeindicies;

  /** Remote variable access: get SmackCluster.nodeindicies */
  public final int[] run_SmackCluster_nodeindicies_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.nodeindicies;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.nodeindicies */
  public final int[] run_SmackCluster_nodeindicies_set_(int[] _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.nodeindicies = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: get SmackCluster.nodeindicies[p0] */
  public final int run_SmackCluster_nodeindicies_get_(int p0) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.nodeindicies[p0];
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.nodeindicies[p0] */
  public final int run_SmackCluster_nodeindicies_set_(int p0, int _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.nodeindicies[p0] = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.nodeindicies[p0] */
  public final int run_SmackCluster_nodeindicies_inc_(int p0, int _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        int _before_ = this.nodeindicies[p0];
        this.nodeindicies[p0] += _value_;
        return _before_;
      } else {
        return this.nodeindicies[p0] += _value_;
      }
    } finally {
      _dec();
    }
  }

  private int[] elementindicies;

  /** Remote variable access: get SmackCluster.elementindicies */
  public final int[] run_SmackCluster_elementindicies_get_() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.elementindicies;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.elementindicies */
  public final int[] run_SmackCluster_elementindicies_set_(int[] _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.elementindicies = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: get SmackCluster.elementindicies[p0] */
  public final int run_SmackCluster_elementindicies_get_(int p0) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.elementindicies[p0];
    } finally {
      _dec();
    }
  }

  /** Remote variable access: set SmackCluster.elementindicies[p0] */
  public final int run_SmackCluster_elementindicies_set_(int p0, int _value_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      return this.elementindicies[p0] = _value_;
    } finally {
      _dec();
    }
  }

  /** Remote variable access: increment SmackCluster.elementindicies[p0] */
  public final int run_SmackCluster_elementindicies_inc_(int p0, int _value_, boolean _post_) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      if (_post_) {
        int _before_ = this.elementindicies[p0];
        this.elementindicies[p0] += _value_;
        return _before_;
      } else {
        return this.elementindicies[p0] += _value_;
      }
    } finally {
      _dec();
    }
  }

  public SmackCluster_instance_impl(int nr_of_CPUs, int client_nr) throws uka.karmi.rmi.RemoteException {
    super();;
    this.nr_of_CPUs = nr_of_CPUs;
    this.client_nr = client_nr;
    ;
  }

  /** Application method of class SmackCluster */
  public void assembleMassMatrix() throws java.lang.Error, jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      {
         int i;
         Node temp_node;
         Element temp_element;
         Constraint temp_constraint;
         try {
            System.out.println("Assembling Elements");
            for (i = 0; i < this.number_of_elements; i++) {
               temp_element = (Element)this.elementlist.elementAt(i);
               temp_element.assembleMassMatrix();
            }
         }  catch (ArrayIndexOutOfBoundsException e) {
            throw new Error("\n* Error during Assembly phase - Terminating" + e);
         } catch (NullPointerException e) {
            throw new Error("\n* Error during Assembly phase of Element\n* This error could be the result of a missing (or wrong) parameter in the indata file \n* " + e);
         } catch (Error e) {
            throw new Error("\n* Error during Assembly phase of Element\n* This error could be the result of a missing (or wrong) parameter in the indata file \n* " + e);
         }
         try {
            System.out.println("Assembling Nodes");
            for (i = 0; i < this.nodelist.size(); i++) {
               temp_node = (Node)this.nodelist.elementAt(i);
               temp_node.determineMassMatrix();
            }
         }  catch (ArrayIndexOutOfBoundsException e) {
            throw new Error("\n* Error during Assembly phase - Terminating" + e);
         } catch (NullPointerException e) {
            throw new Error("\n* Error during Assembly phase of Node \n* This error could be the result of a missing (or wrong) parameter in the indata file \n* " + e);
         } catch (Error e) {
            throw new Error("\n* Error during Assembly phase of Node \n* This error could be the result of a missing (or wrong) parameter in the indata file \n* " + e);
         }
         try {
            System.out.println("Assembling Constraints");
            for (i = 0; i < this.number_of_constraints; i++) {
               temp_constraint = (Constraint)this.constraintlist.elementAt(i);
               temp_constraint.determineMassMatrix(this.nodelist);
            }
         }  catch (ArrayIndexOutOfBoundsException e) {
            throw new Error("\n* Error during Assembly phase - Terminating" + e);
         } catch (NullPointerException e) {
            throw new Error("\n* Error during Assembly phase of Constraint \n* This error could be the result of a missing (or wrong) parameter in the indata file \n* " + e);
         } catch (Error e) {
            throw new Error("\n* Error during Assembly phase of Constraint \n* This error could be the result of a missing (or wrong) parameter in the indata file \n* " + e);
         }
      }
    } finally {
      _dec();
    }
  }

  /** Application method of class SmackCluster */
  public void initialize(java.lang.String fname, run.SmackCluster[] nodes) throws java.lang.Error, java.lang.Exception
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      {
         this.filename = new String(fname);
         this.cluster_nodes = nodes;
         Reader indatafile = new FembicReader(this.filename);
         try {
            this.number_of_elements = indatafile.numberOfElements();
            this.number_of_trackers = indatafile.numberOfTrackers();
            this.number_of_materials = indatafile.numberOfMaterials();
            this.number_of_nodes = indatafile.numberOfNodes();
            this.number_of_constraints = indatafile.numberOfConstraints();
            this.number_of_loads = indatafile.numberOfLoads();
            this.number_of_controls = indatafile.numberOfControls();
         }  catch (java.text.ParseException e) {
            throw new Error("Error in initialization phase \n" + e);
         }
         this.elementlist = new RplVector(nodes);
         this.trackerlist = new RplVector(nodes);
         this.materiallist = new RplVector(nodes);
         this.nodelist = new RplVector(nodes);
         this.constraintlist = new RplVector(nodes);
         this.loadlist = new RplVector(nodes);
         this.controlset = new Controlset(nodes);
         try {
            System.out.println("Reading Constraints");
            indatafile.open();
            for (this.i = 0; this.i < this.number_of_constraints; this.i++) {
               this.constraintlist.addElement(indatafile.getNextConstraint(this.nodelist));
            }
            indatafile.close();
            System.out.println("Filled constraintlist");
            System.out.println("Reading Loads");
            indatafile.open();
            for (this.i = 0; this.i < this.number_of_loads; this.i++) {
               this.loadlist.addElement(indatafile.getNextLoad(this.nodelist));
            }
            indatafile.close();
            System.out.println("Filled loadlist");
            indatafile.open();
            System.out.println("Reading Nodes");
            for (this.i = 0; this.i < this.number_of_nodes; this.i++) {
               this.nodelist.addElement(indatafile.getNextNode(this.constraintlist, this.loadlist));
            }
            indatafile.close();
            System.out.println("Filled nodelist");
            indatafile.open();
            System.out.println("Reading Materials");
            Material m;
            for (this.i = 0; this.i < this.number_of_materials; this.i++) {
               m = indatafile.getNextMaterial();
               if (m.failure_strain_is_set || m.failure_stress_is_set) {
                  this.failure_is_set = true;
               }
               this.materiallist.addElement(m);
            }
            indatafile.close();
            System.out.println("Filled materiallist");
            indatafile.open();
            System.out.println("Reading Elements");
            for (this.i = 0; this.i < this.number_of_elements; this.i++) {
               this.elementlist.addElement(indatafile.getNextElement(this.materiallist, this.nodelist, this.loadlist));
            }
            indatafile.close();
            System.out.println("Filled elementlist");
            indatafile.open();
            System.out.println("Reading Trackers");
            for (this.i = 0; this.i < this.number_of_trackers; this.i++) {
               this.trackerlist.addElement(indatafile.getNextTracker(this.nodelist, this.elementlist));
            }
            indatafile.close();
            System.out.println("Filled trackerlist");
            indatafile.open();
            System.out.println("Reading Controls");
            for (this.i = 0; this.i < this.number_of_controls; this.i++) {
               indatafile.getControlSet(this.controlset);
            }
            indatafile.close();
            System.out.println("Filled controlset");
            this.resultwriter = indatafile.getWriter(this.nodelist, this.elementlist, this.controlset, nodes);
            this.trackwriter = indatafile.getTrackWriter(this.trackerlist, this.controlset, nodes);
         }  catch (java.text.ParseException e) {
            throw new Error("Parameter error in indata file \n" + e + " in line " + e.getErrorOffset());
         } catch (Error e) {
            throw e;
         }
         try {
            this.resultwriter.initialize();
         }  catch (Error e) {
            throw new Error("Initialization error of writer");
         }
         try {
            this.trackwriter.initialize();
         }  catch (Error e) {
            throw new Error("Initialization error of trackwriter");
         }
      }
    } finally {
      _dec();
    }
  }

  /** Application method of class SmackCluster */
  public void post() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      {
      }
    } finally {
      _dec();
    }
  }

  /** Application method of class SmackCluster */
  public void print() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      {
         System.out.println();
         System.out.println();
         System.out.println("time:" + this.time);
         try {
            this.resultwriter.write(this.filename, this.time);
            this.trackwriter.write(this.time);
         }  catch (IOException ioe) {
            System.out.println(ioe);
            return;
         }
      }
    } finally {
      _dec();
    }
  }

  /** Application method of class SmackCluster */
  public void setInitialConditions() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      {
         int i;
         int j;
         Node temp_node;
         Node neighbour_node;
         Element temp_element;
         Tracker temp_tracker;
         Constraint temp_constraint;
         double total_mass;
         System.out.println("Initializing nodes");
         for (i = 0; i < this.nodelist.size(); i++) {
            temp_node = (Node)this.nodelist.elementAt(i);
            temp_node.setInitialConditions();
         }
         System.out.println("Setting up node neighbour handles");
         for (j = 0; j < this.nodelist.size(); j++) {
            temp_node = (Node)this.nodelist.elementAt(j);
            if (j < this.nodelist.size() - 1) {
               temp_node.setRight_neighbour((Node)this.nodelist.elementAt(j + 1));
            }
            if (j > 0) {
               temp_node.setLeft_neighbour((Node)this.nodelist.elementAt(j - 1));
            }
         }
         System.out.println("Sorting nodes");
         for (j = 0; j < this.nodelist.size(); j++) {
            for (i = 0; i < this.nodelist.size(); i++) {
               temp_node = (Node)this.nodelist.elementAt(i);
               temp_node.checkNeighbours();
            }
         }
         System.out.println("Initializing elements");
         for (i = 0; i < this.number_of_elements; i++) {
            temp_element = (Element)this.elementlist.elementAt(i);
            temp_element.setInitialConditions();
         }
         System.out.println("Initializing trackers");
         for (i = 0; i < this.number_of_trackers; i++) {
            temp_tracker = (Tracker)this.trackerlist.elementAt(i);
            temp_tracker.setInitialConditions();
         }
         System.out.println("Initializing constraints");
         for (i = 0; i < this.number_of_constraints; i++) {
            temp_constraint = (Constraint)this.constraintlist.elementAt(i);
            temp_constraint.setInitialConditions();
         }
         this.controlset.setInitialConditions();
         System.out.println("Determining smallest timestep size");
         if (this.controlset.getTimestep(0) == 0) {
            this.autostep = true;
            this.timestep = 1.0E10;
            for (i = 0; i < this.number_of_elements; i++) {
               this.timestep = ((Element)this.elementlist.elementAt(i)).checkTimestep(this.timestep);
            }
         } else {
            this.autostep = false;
            this.timestep = this.controlset.getTimestep(0);
         }
         System.out.println("Determined timestep:" + this.timestep);
         System.out.println("Calculating total model mass");
         total_mass = 0;
         for (i = 0; i < this.nodelist.size(); i++) {
            temp_node = (Node)this.nodelist.elementAt(i);
            total_mass += temp_node.getMass();
         }
         System.out.println("Total model mass = " + total_mass);
      }
    } finally {
      _dec();
    }
  }

  /** Application method of class SmackCluster */
  public void solve(jp.sync.Barrier barrier) throws java.lang.Exception
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      {
         int j;
         long time_info;
         long time_info_tmp;
         long time_remained;
         int number_of_integration_points;
         int time_h;
         int time_m;
         int time_s;
         String time_str;
         long stime;
         time_info = new Date().getTime();
         this.ttemp = 1.0E10;
         for (this.time = this.controlset.getStarttime(); this.time < this.controlset.getEndtime(); this.time += this.timestep) {
            barrier.sync();
            for (this.i = 0; this.i < this.elementindicies.length; this.i++) {
               this.temporary_element = (Element)this.elementlist.elementAt(this.elementindicies[this.i]);
               this.temporary_element.updateLocalCoordinateSystem();
               number_of_integration_points = this.temporary_element.getNumberOfIntegrationPoints();
               for (j = 0; j < number_of_integration_points; j++) {
                  this.temporary_element.calculateStrain(this.timestep, j);
                  this.temporary_element.calculateStress(j, this.timestep);
               }
               for (j = 0; j < number_of_integration_points; j++) {
                  this.temporary_element.calculateNodalForces(j);
               }
               this.temporary_element.calculateExternalForces(this.time);
               this.temporary_element.calculateContactForces();
               if (this.autostep == true) {
                  this.ttemp = this.temporary_element.checkTimestep(this.ttemp);
               }
            }
            this.exported_ttemp = this.ttemp;
            barrier.sync();
            for (this.i = 0; this.i < this.number_of_constraints; this.i++) {
               this.temporary_constraint = (Constraint)this.constraintlist.elementAt(this.i);
               this.temporary_constraint.update();
            }
            this.nodelist.collectiveUpdate();
            if (this.client_nr == 0) {
               for (this.i = 0; this.i < this.nodelist.size(); this.i++) {
                  this.temporary_node = (Node)this.nodelist.elementAt(this.i);
                  this.temporary_node.calculateNewPosition(this.timestep, this.time);
                  this.temporary_node.checkNeighbours();
               }
               for (this.i = 0; this.i < this.number_of_trackers; this.i++) {
                  this.temporary_tracker = (Tracker)this.trackerlist.elementAt(this.i);
                  this.temporary_tracker.collectData();
                  this.temporary_tracker.calculate();
               }
            }
            if (this.controlset.getTimestep(this.time) == 0) {
               this.autostep = true;
               for (this.i = 0; this.i < this.nr_of_CPUs; this.i++) {
                  if (this.i != this.client_nr) this.ttemp = Math.min(this.ttemp, this.cluster_nodes[this.i].getTtemp());
               }
               this.timestep = this.ttemp;
               this.ttemp = 1.0E10;
            } else {
               this.autostep = false;
               this.timestep = this.controlset.getTimestep(this.time);
            }
            if (this.controlset.timeToPrint(this.time)) {
               this.elementlist.collectiveUpdate();
               if (this.client_nr == 0) {
                  System.out.println();
                  System.out.println();
                  time_info_tmp = new Date().getTime();
                  time_remained = (time_info_tmp - time_info) * (int)((this.controlset.getEndtime() - this.time) / this.controlset.getPrintstep()) / 1000;
                  time_h = (int)(time_remained / 3600);
                  time_m = (int)(time_remained / 60 - time_h * 60);
                  time_s = (int)(time_remained - (int)(time_remained / 60) * 60);
                  time_str = "";
                  if (time_h < 10) {
                     time_str += "0" + time_h;
                  } else {
                     time_str += time_h;
                  }
                  if (time_m < 10) {
                     time_str += ":0" + time_m;
                  } else {
                     time_str += ":" + time_m;
                  }
                  if (time_s < 10) {
                     time_str += ":0" + time_s;
                  } else {
                     time_str += ":" + time_s;
                  }
                  System.out.println("time:" + this.time + "\tRemaining time (hh:mm:ss) " + time_str);
                  time_info = time_info_tmp;
                  try {
                     this.resultwriter.write(this.filename, this.time);
                  }  catch (IOException ioe) {
                     System.out.println(ioe);
                     return;
                  }
               }
            }
            if (this.controlset.timeToPrintTracker(this.time)) {
               if (!this.controlset.timeToPrint(this.time)) this.elementlist.collectiveUpdate();
               if (this.client_nr == 0) {
                  this.trackwriter.write(this.time);
               }
            }
            barrier.sync();
            for (this.i = 0; this.i < this.nodeindicies.length; this.i++) {
               this.temporary_node = (Node)this.nodelist.elementAt(this.nodeindicies[this.i]);
               this.temporary_node.clearNodalForces();
            }
            this.nodelist.collectiveUpdate();
         }
         this.post();
      }
    } finally {
      _dec();
    }
  }

  /** Application method of class SmackCluster */
  public void passReferences() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      {
         for (int i = 1; i < this.cluster_nodes.length; i++) {
            this.cluster_nodes[i].setReferences(this.constraintlist, this.nodelist, this.loadlist, this.elementlist, this.materiallist, this.trackerlist, this.controlset, this.resultwriter, this.trackwriter, this.cluster_nodes);
            this.cluster_nodes[i].setVariables(this.number_of_constraints, this.number_of_nodes, this.number_of_loads, this.number_of_elements, this.number_of_materials, this.number_of_trackers, this.number_of_controls, this.timestep, this.autostep);
         }
         try {
            this.constraintlist.exclusiveUpdate();
            this.loadlist.exclusiveUpdate();
            this.nodelist.exclusiveUpdate();
            this.elementlist.exclusiveUpdate();
            this.materiallist.exclusiveUpdate();
            this.trackerlist.exclusiveUpdate();
            this.controlset.exclusiveUpdate();
            this.resultwriter.exclusiveUpdate();
            this.trackwriter.exclusiveUpdate();
         }  catch (java.io.IOException ioe) {
            System.out.println(ioe);
         } catch (ClassNotFoundException e) {
            e.printStackTrace();
         }
      }
    } finally {
      _dec();
    }
  }

  /** Application method of class SmackCluster */
  public void setReferences(run.RplVector cl, run.RplVector nl, run.RplVector ll, run.RplVector el, run.RplVector ml, run.RplVector tl, run.Controlset cs, run.Writer rw, run.TrackWriter tw, run.SmackCluster[] nod) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      {
         this.constraintlist = cl;
         this.nodelist = nl;
         this.loadlist = ll;
         this.elementlist = el;
         this.materiallist = ml;
         this.trackerlist = tl;
         this.controlset = cs;
         this.resultwriter = rw;
         this.trackwriter = tw;
         this.cluster_nodes = nod;
      }
    } finally {
      _dec();
    }
  }

  /** Application method of class SmackCluster */
  public void setVariables(int noc, int non, int nol, int noe, int nom, int not, int noctrl, double timestep, boolean autostep) throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      {
         this.number_of_constraints = noc;
         this.number_of_nodes = non;
         this.number_of_loads = nol;
         this.number_of_elements = noe;
         this.number_of_materials = nom;
         this.number_of_trackers = not;
         this.number_of_controls = noctrl;
         this.timestep = timestep;
         this.autostep = autostep;
      }
    } finally {
      _dec();
    }
  }

  /** Application method of class SmackCluster */
  public double getTtemp() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      {
         return this.exported_ttemp;
      }
    } finally {
      _dec();
    }
  }

  /** Application method of class SmackCluster */
  public void determineDistribution() throws jp.lang.MovedException
  {
    // method counting for migration control
    _inc();
    try {
      // application code
      {
         Vector node = new Vector();
         Vector element = new Vector();
         Node tempnode;
         Element tempelement;
         int index;
         index = 0;
         tempnode = (Node)this.nodelist.firstElement();
         while (tempnode.getLeft_neighbour() != null) tempnode = tempnode.getLeft_neighbour();
         for (this.i = 0; this.i < this.nodelist.size(); this.i++) {
            tempnode.setCpu_number(this.i * this.nr_of_CPUs / this.nodelist.size());
            tempnode = tempnode.getRight_neighbour();
            if (this.i * this.nr_of_CPUs / this.nodelist.size() == this.client_nr) index++;
         }
         this.nodeindicies = new int[index];
         index = 0;
         for (int i = 0; i < this.nodelist.size(); i++) {
            tempnode = (Node)this.nodelist.elementAt(i);
            if (tempnode.getCpu_number() == this.client_nr) this.nodeindicies[index++] = i;
         }
         index = 0;
         for (int i = 0; i < this.elementlist.size(); i++) {
            tempelement = (Element)this.elementlist.elementAt(i);
            if (tempelement.getCpu_number() == this.client_nr) index++;
         }
         this.elementindicies = new int[index];
         index = 0;
         for (int i = 0; i < this.elementlist.size(); i++) {
            tempelement = (Element)this.elementlist.elementAt(i);
            if (tempelement.getCpu_number() == this.client_nr) this.elementindicies[index++] = i;
         }
      }
    } finally {
      _dec();
    }
  }

  /** @see RemoteObject.__init() */
  protected void __init() {
    _this = new SmackCluster((jp.lang.Marker) null);
    _this._init(_getRef());
  }

  /** Called to free heap space after object migration.
      @see RemoteObject._cleanup() */
  protected void _cleanup() {
    super._cleanup();
    this.constraintlist = null;
    this.loadlist = null;
    this.nodelist = null;
    this.elementlist = null;
    this.trackerlist = null;
    this.materiallist = null;
    this.controlset = null;
    this.temporary_element = null;
    this.temporary_tracker = null;
    this.temporary_constraint = null;
    this.temporary_node = null;
    this.resultwriter = null;
    this.trackwriter = null;
    this.filename = null;
    this.cluster_nodes = null;
    this.nodeindicies = null;
    this.elementindicies = null;
  }

}
