DoubleBlockPiecewiseSampledDataStaticSystem.java

/*
 * Created on 2007/04/11
 * Copyright (C) 2007 Koga Laboratory. All rights reserved.
 *
 */
package org.mklab.tool.control.system.sampled;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.mklab.nfc.matrix.DoubleMatrix;
import org.mklab.nfc.ode.DoublePiecewiseContinuousAlgebraicSystem;
import org.mklab.nfc.ode.DoublePiecewiseContinuousDiscreteAlgebraicSystem;
import org.mklab.nfc.ode.SolverStopException;
import org.mklab.tool.control.system.DoubleSystemOperator;


/**
 * ブロック区分的連続サンプル値静的システムを表わすクラスです。
 * 
 * @author koga
 * @version $Revision: 1.9 $, 2007/04/11
 */
public class DoubleBlockPiecewiseSampledDataStaticSystem extends DoubleBlockSampledDataStaticSystem implements DoublePiecewiseContinuousDiscreteAlgebraicSystem {

  /** 区分的連続離散代数システムのリスト */
  private List<DoublePiecewiseContinuousDiscreteAlgebraicSystem> piecewiseContinuousDiscreteAlgebraicSystems = new ArrayList<>();

  /** 区分的連続代数システムのリスト */
  private List<DoublePiecewiseContinuousAlgebraicSystem> piecewiseContinuousAlgebraicSystems = new ArrayList<>();

  /**
   * 新しく生成された<code>BlockPiecewiseSampledDataStaticSystem</code>オブジェクトを初期化します。
   * 
   * @param elements 隣接行列
   * @param inputNodes 入力ノード番号のリスト(番号は1から始まる)
   * @param outputNodes 出力ノード番号のリスト(番号は1から始まる)
   */
  public DoubleBlockPiecewiseSampledDataStaticSystem(DoubleSystemOperator[][] elements, List<Integer> inputNodes, List<Integer> outputNodes) {
    super(elements, inputNodes, outputNodes);
    setupPiecewiseContinuousDiscreteSystems();
    setupPiecewiseContinuousSystems();
  }

  /**
   * {@inheritDoc}
   */
  @SuppressWarnings("boxing")
  public double getDiscontinuousPoint(final double t1,  final DoubleMatrix input1, final double t2,  final DoubleMatrix input2) throws SolverStopException {
    outputEquation(t1);
    final List<DoubleMatrix> inputsDiscrete1 = getInputsToPiecewiseContinuousDiscreteAlgebraicSystems();
    final List<DoubleMatrix> inputsContinuous1 = getInputsToPiecewiseContinuousAlgebraicSystems();

    outputEquation(t2);
    final List<DoubleMatrix> inputsDiscrete2 = getInputsToPiecewiseContinuousDiscreteAlgebraicSystems();
    final List<DoubleMatrix> inputsContinuous2 = getInputsToPiecewiseContinuousAlgebraicSystems();

    final List<Double> continuousDiscreteDiscontinuousPoints = getContinuousDiscreteDiscontinuousPoints(t1, inputsDiscrete1, t2, inputsDiscrete2);
    final List<Double> continuousDiscontinuousPoints = getContinuousDiscontinuousPoints(t1, inputsContinuous1, t2, inputsContinuous2);

    outputEquation(t1);

    final List<Double> discontinuousPoints = continuousDiscreteDiscontinuousPoints;
    discontinuousPoints.addAll(continuousDiscontinuousPoints);

    final Double[] sortedPoints = discontinuousPoints.toArray(new Double[discontinuousPoints.size()]);
    Arrays.sort(sortedPoints);

    return sortedPoints[0];
  }

  /**
   * {@inheritDoc}
   */
  public List<Integer> getPiece(final double t,  final DoubleMatrix u) throws SolverStopException {
    calcNodeValue(t);

    final List<Integer> continuousDiscretePieces = getContinuousDiscretePieces(t);
    final List<Integer> continuousPieces = getContinuousPieces(t);

    final List<Integer> pieces = continuousDiscretePieces;
    pieces.addAll(continuousPieces);

    return pieces;
  }

  /**
   * 連続離散システムの区分の番号のリストを返します。
   * 
   * @param t 時刻
   * 
   * @return 連続離散システムの区分の番号のリスト
   * @exception SolverStopException ソルバーが停止された場合
   */
  private List<Integer> getContinuousDiscretePieces(final double t) throws SolverStopException {
    final List<Integer> pieces = new ArrayList<>();
    for (DoublePiecewiseContinuousDiscreteAlgebraicSystem system : this.piecewiseContinuousDiscreteAlgebraicSystems) {
      pieces.addAll(system.getPiece(t, getInputNodeValueOf((DoubleSystemOperator)system)));
    }
    return pieces;
  }

  /**
   * 連続システムの区分の番号のリストを返します。
   * 
   * @param t 時刻
   * 
   * @return 連続離散システムの区分の番号のリスト
   * @exception SolverStopException ソルバーが停止された場合
   */
  private List<Integer> getContinuousPieces(final double t) throws SolverStopException {
    final List<Integer> pieces = new ArrayList<>();
    for (DoublePiecewiseContinuousAlgebraicSystem system : this.piecewiseContinuousAlgebraicSystems) {
      pieces.addAll(system.getPiece(t, getInputNodeValueOf((DoubleSystemOperator)system)));
    }
    return pieces;
  }

  /**
   * 区分的連続離散システムのリストを設定します。
   */
  private void setupPiecewiseContinuousDiscreteSystems() {
    this.piecewiseContinuousDiscreteAlgebraicSystems.clear();

    final int size = getNodeSize();

    for (int row = 0; row < size; row++) {
      for (int column = 0; column < size; column++) {
        final DoubleSystemOperator system = getSystemOperator(row, column);
        if (system instanceof DoublePiecewiseContinuousDiscreteAlgebraicSystem) {
          this.piecewiseContinuousDiscreteAlgebraicSystems.add((DoublePiecewiseContinuousDiscreteAlgebraicSystem)system);
        }
      }
    }
  }

  /**
   * 区分的連続システムのリストを設定します。
   */
  private void setupPiecewiseContinuousSystems() {
    this.piecewiseContinuousAlgebraicSystems.clear();

    final int size = getNodeSize();

    for (int row = 0; row < size; row++) {
      for (int column = 0; column < size; column++) {
        final DoubleSystemOperator system = getSystemOperator(row, column);
        if (system instanceof DoublePiecewiseContinuousAlgebraicSystem) {
          this.piecewiseContinuousAlgebraicSystems.add((DoublePiecewiseContinuousAlgebraicSystem)system);
        }
      }
    }
  }

  /**
   * 区分的連続離散代数システムへの入力を返します。
   * 
   * @return 区分的連続離散代数システムへの入力
   */
  private List<DoubleMatrix> getInputsToPiecewiseContinuousDiscreteAlgebraicSystems() {
    final List<DoubleMatrix> inputs = new ArrayList<>();
    for (DoublePiecewiseContinuousDiscreteAlgebraicSystem system : this.piecewiseContinuousDiscreteAlgebraicSystems) {
      inputs.add(getInputNodeValueOf((DoubleSystemOperator)system).createClone());
    }
    return inputs;
  }

  /**
   * 区分的連続代数システムへの入力を返します。
   * 
   * @return 区分的連続代数システムへの入力
   */
  private List<DoubleMatrix> getInputsToPiecewiseContinuousAlgebraicSystems() {
    final List<DoubleMatrix> inputs = new ArrayList<>();
    for (DoublePiecewiseContinuousAlgebraicSystem system : this.piecewiseContinuousAlgebraicSystems) {
      inputs.add(getInputNodeValueOf((DoubleSystemOperator)system).createClone());
    }
    return inputs;
  }

  /**
   * 指定された区間内([(t1,inputs1),(t2,inputs2)]の連続離散システムの不連続点の時刻を返します。
   * 
   * @param t1 不連続点の前の時刻
   * @param inputs1 不連続点の前の入力
   * @param t2 不連続点の後の時刻
   * @param inputs2 不連続点の後の入力
   * @return 指定された区間内([(t1,inputs1),(t2,inputs2)]の不連続点の時刻
   * @exception SolverStopException ソルバー停止された場合
   */
  @SuppressWarnings("boxing")
  private List<Double> getContinuousDiscreteDiscontinuousPoints(final double t1, final List<DoubleMatrix> inputs1, final double t2, final List<DoubleMatrix> inputs2) throws SolverStopException {
    final List<Double> points = new ArrayList<>();
    for (int i = 0; i < this.piecewiseContinuousDiscreteAlgebraicSystems.size(); i++) {
      final DoublePiecewiseContinuousDiscreteAlgebraicSystem system = this.piecewiseContinuousDiscreteAlgebraicSystems.get(i);
      final DoubleMatrix u1 = inputs1.get(i);
      final DoubleMatrix u2 = inputs2.get(i);
      points.add(system.getDiscontinuousPoint(t1, u1, t2, u2));
    }
    return points;
  }

  /**
   * 指定された区間内([(t1,inputs1),(t2,inputs2)]の連続システムの不連続点の時刻を返します。
   * 
   * @param t1 不連続点の前の時刻
   * @param inputs1 不連続点の前の入力
   * @param t2 不連続点の後の時刻
   * @param inputs2 不連続点の後の入力
   * @return 指定された区間内([(t1,inputs1),(t2,inputs2)]の不連続点の時刻
   * @exception SolverStopException ソルバーが停止された場合
   */
  @SuppressWarnings("boxing")
  private List<Double> getContinuousDiscontinuousPoints(final double t1, final List<DoubleMatrix> inputs1, final double t2, final List<DoubleMatrix> inputs2) throws SolverStopException {
    final List<Double> points = new ArrayList<>();
    for (int i = 0; i < this.piecewiseContinuousAlgebraicSystems.size(); i++) {
      final DoublePiecewiseContinuousAlgebraicSystem system = this.piecewiseContinuousAlgebraicSystems.get(i);
      final DoubleMatrix u1 = inputs1.get(i);
      final DoubleMatrix u2 = inputs2.get(i);
      points.add(system.getDiscontinuousPoint(t1, u1, t2, u2));
    }
    return points;
  }
}