DoubleUserDefinedContinuousDynamicSystem.java

/*
 * Created on 2007/07/16
 * Copyright (C) 2007 Koga Laboratory. All rights reserved.
 *
 */
package org.mklab.tool.control.system.continuous;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Set;

import org.mklab.nfc.matrix.DoubleMatrix;
import org.mklab.nfc.ode.SolverStopException;
import org.mklab.tool.control.system.ParameterUtil;
import org.mklab.tool.control.system.UserDefinedSystem;
import org.mklab.tool.control.system.parameter.NoSuchParameterException;
import org.mklab.tool.control.system.parameter.ParameterException;


/**
 * ユーザ定義連続時間動的システムを表わすクラスです。
 * 
 * @author koga
 * @version $Revision: 1.14 $, 2007/07/16
 */
public abstract class DoubleUserDefinedContinuousDynamicSystem extends DoubleBaseContinuousDynamicSystem implements UserDefinedSystem {

  /** システムを定義したクラス */
  private Class<?> systemKlass;

  /** システムの初期化処理を定義したメソッド */
  private Method initializeFunction;

  /** システムの更新処理を定義したメソッド */
  private Method updateFunction;

  /** システムの状態方程式を定義したメソッド */
  protected Method stateFunction;

  /** システムの出力方程式を定義したメソッド */
  private Method outputFunction;

  /** 対象オブジェクト */
  protected Object object;

  /**
   * 新しく生成された<code>UserDefinedDynamicSystem</code>オブジェクトを初期化します。
   * 
   * @param obj 呼び出し対象オブジェクト。nullの場合は静的メソッドを参照します
   */
  public DoubleUserDefinedContinuousDynamicSystem(Object obj) {
    super(1, 1, 1);
    setHasDirectFeedthrough(true);
    this.object = obj;
  }

  /**
   * 新しく生成された<code>UserDefinedContinuousDynamicSystem</code>オブジェクトを初期化します。
   */
  public DoubleUserDefinedContinuousDynamicSystem() {
    this(null);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public DoubleMatrix outputEquation(double t, DoubleMatrix x, DoubleMatrix u) throws SolverStopException {
    try {
      return (DoubleMatrix)this.outputFunction.invoke(this.object, Double.valueOf(t), x, u);
    } catch (IllegalArgumentException e) {
      throw new SolverStopException(e);
    } catch (IllegalAccessException e) {
      throw new SolverStopException(e);
    } catch (InvocationTargetException e) {
      throw new SolverStopException(e.getTargetException());
    } catch (Exception e) {
      throw new SolverStopException(e);
    }
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public DoubleMatrix outputEquation(double t, DoubleMatrix x) throws SolverStopException {
    try {
      return (DoubleMatrix)this.outputFunction.invoke(this.object, Double.valueOf(t), x);
    } catch (IllegalArgumentException e) {
      throw new SolverStopException(e);
    } catch (IllegalAccessException e) {
      throw new SolverStopException(e);
    } catch (InvocationTargetException e) {
      throw new SolverStopException(e.getTargetException());
    } catch (Exception e) {
      throw new SolverStopException(e);
    }
  }
  
  /**
   * {@inheritDoc}
   */
  public void setSystemClass(final Class<?> klass) {
    this.systemKlass = klass;
  }

  /**
   * {@inheritDoc}
   */
  public Class<?> getSystemClass() {
    return this.systemKlass;
  }

  /**
   * システムの状態方程式を定義したメソッドを設定します。
   * 
   * @param method システムの状態方程式を定義したメソッド
   * @throws SecurityException メソッドにアクセスする権利が無い場合
   */
  public void setStateFunction(final Method method) throws SecurityException {
    this.stateFunction = method;
    this.stateFunction.setAccessible(true);
  }

  /**
   * システムの出力方程式を定義したメソッドを設定します。
   * 
   * @param method システムの出力方程式を定義したメソッド
   * @throws SecurityException メソッドにアクセスする権利が無い場合
   */
  public void setOutputFunction(final Method method) throws SecurityException {
    this.outputFunction = method;
    this.outputFunction.setAccessible(true);
  }

  /**
   * {@inheritDoc}
   */
  public void setInitializeFunction(final Method method) throws SecurityException {
    this.initializeFunction = method;
    this.initializeFunction.setAccessible(true);
  }

  /**
   * {@inheritDoc}
   */
  public void setUpdateFunction(final Method method) throws SecurityException {
    this.updateFunction = method;
    this.updateFunction.setAccessible(true);
  }

  /**
   * {@inheritDoc}
   */
  public Object getParameterValue(String name) throws NoSuchParameterException {
    return ParameterUtil.getValue(this.systemKlass, name);
  }

  /**
   * {@inheritDoc}
   */
  public Set<String> getParameterNames() throws NoSuchParameterException {
    return ParameterUtil.getParameterNames(this.systemKlass);
  }

  /**
   * {@inheritDoc}
   */
  public void setParameterValue(String name, Object value) throws NoSuchParameterException {
    ParameterUtil.setValue(this.systemKlass, name, value);
  }
   
  /**
   * {@inheritDoc}
   */
  public boolean containParameter(String name) {
    return ParameterUtil.contains(this.systemKlass, name);
  }

  /**
   * {@inheritDoc}
   */
  public void update() throws ParameterException {
    try {
      this.updateFunction.invoke(this.object);
    } catch (IllegalArgumentException e) {
      throw new ParameterException(e);
    } catch (IllegalAccessException e) {
      throw new ParameterException(e);
    } catch (InvocationTargetException e) {
      throw new ParameterException(e.getTargetException());
    } catch (Exception e) {
      throw new ParameterException(e);
    }
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public void initialize() {
    super.initialize();
    try {
      if (this.initializeFunction != null) {
        this.initializeFunction.invoke(this.object);
      }
    } catch (IllegalArgumentException e) {
      throw new RuntimeException(e);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    } catch (InvocationTargetException e) {
      throw new RuntimeException(e.getTargetException());
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  /**
   * 直達項があるか(出力が入力に直接依存するか)設定します。
   * 
   * @param hasDirectFeedthrough 直達項があれば(出力が入力に直接依存すれば)true、そうでなければfalse
   */
  public void setDirectFeedthrough(final boolean hasDirectFeedthrough) {
    setHasDirectFeedthrough(hasDirectFeedthrough);
  }
}