===Open MPI のインストール===
yumコマンドを使ってインストールをしていきましょう。 
$ yum install openmpi
$ yum install openmpi-devel

===Cuda7.5 のインストール===
まず、EPELリポジトリを使えるようにしておくと良いので、EPELレポジトリを使っていない方は、使えるようにしましょう。
$ yum install epel-release.noarch
次に、Cuda7.5のダウンロードとインストールです。
$ wget　http://developer.download.nvidia.com/compute/cuda/7.5/Prod/local_installers/cuda-repo-rhel7-7-5-local-7.5-18.x86_64.rpm
$ rpm -i cuda-repo-rhel7-7-5-local-7.5-18.x86_64.rpm
$ yum clean all
$ yum install cuda-7-5.x86_64
再起動します。
$ reboot

===Relion2.0 のインストール===
まず、cmake3コマンドとpatchコマンドを使えるようにしましょう。
$ yum install cmake3
$ yum install patch
Relion2.0のダウンロードとインストールを行います。
$ git clone https://github.com/3dem/relion.git
$ cd relion
$ mkdir build
$ cd build
$ cmake3
$ make
エラーが出なければ、無事、インストール完了です。
最後に[http://www.yasunaga-lab.bio.kyutech.ac.jp/EosJ/index.php/RELION2%E3%81%AEScientificLinux7%E3%81%B8%E3%81%AE%E5%B0%8E%E5%85%A5#.E7.92.B0.E5.A2.83.E8.A8.AD.E5.AE.9A 環境設定]を行います。
$ export PATH=/***/relion/build/bin:$PATH
$ export LD_LIBRARY_PATH=/***/relion/build//lib:$LD_LIBRARY_PATH
$ export RELION_QSUB_TEMPLATE="/***/relion/build/bin/relion_qsub.csh"
"***"には、relionフォルダまでのパスを書き込んでください。
$relion
でRelionが起動するはずです。

===MotionCor2===
実行ファイルを
http://msg.ucsf.edu/em/software/motioncor2.html
からダウンロードします。 
そのまま実行しようとすると、libcufft.so.7.5やlibtiff.so.3がないとエラーが出たので、
$ echo “/usr/local/cuda-7.5/targets/x86_64-linux/lib” > /etc/ld.so.conf.d/cuda.conf
$ ldconfig
$ yum install campat-libtiff3
を行います。 
relionからMotionCor2が実行できるよう、[http://www.yasunaga-lab.bio.kyutech.ac.jp/EosJ/index.php/RELION2%E3%81%AEScientificLinux7%E3%81%B8%E3%81%AE%E5%B0%8E%E5%85%A5#.E7.92.B0.E5.A2.83.E8.A8.AD.E5.AE.9A 環境設定]を行います。

===CTFFIND4.1===
実行ファイルをhttp://grigoriefflab.janelia.org/ctfからダウンロードします。 
ダウンロードするものは、"ctffind-4.1.5.tar.gz"です。解答して使います。 
relionからCTFFIND4.1が実行できるよう、[http://www.yasunaga-lab.bio.kyutech.ac.jp/EosJ/index.php/RELION2%E3%81%AEScientificLinux7%E3%81%B8%E3%81%AE%E5%B0%8E%E5%85%A5#.E7.92.B0.E5.A2.83.E8.A8.AD.E5.AE.9A 環境設定]を行います。

===RESMAP===
実行ファイルをhttp://resmap.sourceforge.net/からダウンロードします。
$ python --version・・・バージョンを確認。>2.7が必要
$ yum install numpy・・・>1.6が必要
$ yum install scipy・・・>0.12が必要
$ yum install python-matplotlib・・・>1.2が必要
relionからRESMAPが実行できるよう、[http://www.yasunaga-lab.bio.kyutech.ac.jp/EosJ/index.php/RELION2%E3%81%AEScientificLinux7%E3%81%B8%E3%81%AE%E5%B0%8E%E5%85%A5#.E7.92.B0.E5.A2.83.E8.A8.AD.E5.AE.9A 環境設定]を行います。

===環境設定===
#Setup openMPI
export PATH=/usr/lib64/openmpi/bin:$PATH
export LD_LIBRARY_PATH=/usr/lib64/openmpi/lib:$LD_LIBRARY_PATH

#Setup RELION
#Relion-1.4#
#export PATH=/home/people/takahiro/src/relion-1.4/bin:$PATH
#export LD_LIBRARY_PATH=/home/people/takahieo/src/relion-1.4/lib:$LD_LIBRARY_PATH
#export RELION_QSUB_TEMPLATE="/home/people/takahiro/src/relion-1.4/bin/qsub.csh"
#Relion-2.0#
export PATH=/home/people/takahiro/src/relion2-beta/build/bin:$PATH
export LD_LIBRARY_PATH=/home/people/takahieo/src/relion2-beta/build/lib:$LD_LIBRARY_PATH

# Where is qsub template script stored
export RELION_QSUB_TEMPLATE="/home/people/takahiro/src/relion2-beta/build/bin/relion_qsub.csh"

# Default PDF viewer
export RELION_PDFVIEWER_EXECUTABLE="evince"

# Default MOTIONCORR executable
export RELION_MOTIONCORR_EXECUTABLE="/home/people/takahiro/src/MotionCor2-10-19-2016"

# For CTFFIND3 this would be
#export RELION_CTFFIND_EXECUTABLE="/home/people/takahiro/src/ctf/ctffind3_mp.exe"
# For Ctffind3_mp
#export NCPUS=32
# Default CTFFIND executable, version 4.1.x
export RELION_CTFFIND_EXECUTABLE="/home/people/takahiro/src/ctffind-4.1.5/ctffind"

# Default ResMap executable
export RELION_RESMAP_EXECUTABLE="/home/people/takahiro/src/ResMap-1.1.4-linux64"

# Enforce cluster jobs to occupy entire nodes with 24 hyperthreads
export RELION_MINIMUM_DEDICATED=24
# Do not allow the user to change the enforcement of entire nodes
export RELION_ALLOW_CHANGE_MINIMUM_DEDICATED=0

# Ask for confirmation if users try to submit local jobs with more than 12 MPI nodes
export RELION_WARNING_LOCAL_MPI=12
↑何のためかよくわからないが、Relionのホームページに載っていた

# CUDA for RELION
export PATH=/usr/local/cuda/bin:$PATH
export LD_LIBRARY_PATH=/use/local/cuda/lib64:$LD_LIBRARY_PATH
export CUDA_HOME="/usr/local/cuda"

===その他===
gsコマンド
latexコマンド
dvipdfコマンド

RELION2のScientificLinux7への導入

2016-04-20T07:05:36Z

Takahiro: /* 基本１１（ループ文２） */

'''PIONE'''チュートリアル 
　ここでは、[[PIONE]]のチュートリアルを行います。始める前に[[PIONEのインストール]]をしておきましょう。

== 基本 ==
=== 基本１（特定のファイルを出力する） ===

　まず、PIONEを動かすにはルール定義書をつくる必要があります。 
どんな言語でも最初に作成するHelloプログラムを作ってみましょう。

　次の内容のファイル'HelloWorld.pione'を作成してみましょう。

Rule Main
output 'message.txt'

Action
echo "Hello PIONE world !" > message.txt
End

このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic1 こちら]からダウンロードできます。 
この後、[[pione-client]]を実行します。

$ pione-client HelloWorld.pione -b helloOutput

例えば、次のような出力が流れます。

==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{})
==> &Anonymous:Main([],{})
SH ------------------------------------------------------------
SH echo "Hello PIONE world !" > message.txt
SH ------------------------------------------------------------
<== &Anonymous:Main([],{})
<-- Distribution: &Anonymous:Root([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})

その結果、helloOutputというディレクトリができます。その中に指定したファイルmessage.txtが出力されています。

$ cat helloOutput/output/message.txt

Hello PIONE world !

もう一度、実行すると今度は、実行の必要がないために次のようなものが出力されます。

==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})

さっきと比べると、Main Ruleが動いていないことが分かります。 
　さて、改めて設定したファイルを眺めてみます。 
まず、最初に呼び出されるルール（Main)が定義されています。

Rule Main

Mainは、Ｃ言語などと同様に特別な意味をもつルールです。 
次に、出力ファイルが定義されています。

output 'message.txt'

ここに書かれたファイルが最終的に-bで指定されたディレクトリに出力として戻ってきます。 
Action以降が実際に起動するプログラムになります。

Action
echo "Hello PIONE world !" > message.txt

実際にはシェルスクリプトが動きますので、どんなものも実行が可能です。

#!/bin/csh

で始めれば、cshを使って記述することもできますし、スクリプト系の言語であれば自由に記述し、実行形式を実行出来ます。 
最後に、RuleをEndで終了します。

End

これが、一番シンプルなルールの書き方です。入力ファイルがないので、出力ファイルがなければ作成し、あれば作成しないという動作をします。 
必要以上の動作をしないところが通常のシェルスクリプトを実行する場合と異なる点です。

=== 基本２（特定のファイルを入力し、出力する（更新判定）） ===

　次に、入力ファイルから出力ファイルを作成する場合の定義書について作成してみましょう。

#Multiplying.pione

Rule Main
input 'test.in'
output 'test.out'

Action
awk '{ print $1*2 }' {$I[1]} > {$O[1]}
End

このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic2 こちら]からダウンロードできます。 
今回は、test.inという入力ファイルの中にある行頭の数字を２倍して、test.outというファイルを作り出すルールです (awkの使い方については、別途勉強してみて下さい)。 
入力ファイルの更新判定により、ルールを実行するかどうかが変わってきます。

　まず、

$ mkdir MultiplyingInput
$ pione-client Multiplying.pione -b MultiplyingOutput -i MultiplyingInput/

として、入力ファイルがあるディレクトリ（指定しなければ、現在のディレクトリ）を指定して実行してみます。

==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})

入力ファイルがありませんので、何もする事がないとして終了してしまいます。先ほどとの違いに気がついたでしょうか。

　次に、ファイルを作成して、実行してみます。

$ echo "3" > MultiplyingInput/test.in
$ echo "5" >> MultiplyingInput/test.in
$ cat MultiplyingInput/test.in
3
5
$ pione-client Multiplying.pione -b MultiplyingOutput -i MultiplyingInput/
==> &Anonymous:Root([test.in],{})
--> Rule Application: &Anonymous:Root([test.in],{})
--> Distribution: &Anonymous:Root([test.in],{})
>>> &Anonymous:Main([test.in],{})
==> &Anonymous:Main([test.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<-- Distribution: &Anonymous:Root([test.in],{})
<-- Rule Application: &Anonymous:Root([test.in],{})
<== &Anonymous:Main([test.in],{})
<== &Anonymous:Root([test.in],{})

$ cat MultiplyingOutput/output/test.out
6
10

となり、確かに２倍の値のファイルができあがっていることが分かります。 
もう一度、実行すると、

$ pione-client Multiplying.pione -b MultiplyingOutput -i MultiplyingInput/
==> &Anonymous:Root([test.in],{})
--> Rule Application: &Anonymous:Root([test.in],{})
<-- Rule Application: &Anonymous:Root([test.in],{})
<== &Anonymous:Root([test.in],{})

となり、ここでも何も実行しません。 
つまり、入力ファイルに比べて出力ファイルのほうが新しいので、更新判定の結果、実行しなくてよいと判断したことになります。賢いですね。

　ここで、ファイルを更新してみましょう。３行目に7を付け加えます。

$ echo "7" >> MultiplyingInput/test.in

そして、実行してみましょう。

$ pione-client Multiplying.pione -b MultiplyingOutput -i MultiplyingInput/
==> &Anonymous:Root([test.in],{})
--> Rule Application: &Anonymous:Root([test.in],{})
--> Distribution: &Anonymous:Root([test.in],{})
>>> &Anonymous:Main([test.in],{})
==> &Anonymous:Main([test.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<-- Distribution: &Anonymous:Root([test.in],{})
<== &Anonymous:Main([test.in],{})
<-- Rule Application: &Anonymous:Root([test.in],{})
<== &Anonymous:Root([test.in],{})

$ cat MultiplyingOutput/output/test.out
6
10
14

今度は実行されました。これが更新判定によりルールが実行されるかどうかが判定されているということです。 
もう一度実行しても、今度は実行されません。

$ pione-client Multiplying.pione -b MultiplyingOutput -i MultiplyingInput/
==> &Anonymous:Root([test.in],{})
--> Rule Application: &Anonymous:Root([test.in],{})
<-- Rule Application: &Anonymous:Root([test.in],{})
<== &Anonymous:Root([test.in],{})

さて、出力ファイルを削除してみるとどうなるでしょうか。

$ rm MultiplyingOutput/output/test.out

今度は、実行されますね。

　では、内容は変えずに、touch コマンドを使って、入力ファイルの修正時刻を変えるとどうなるでしょうか。

$ touch MultiplyingInput/test.in

今回も、予想通り、動作しました。 
もし、動作しないようだったら、バグです。すぐに、[https://github.com/pione GITHUB/PIONE]に報告しましょう。 
この基本２が理解できれば、まず、PIONEの動きの基本が理解できたことになります。

　ところで、Actionで定義した動作の中に、見慣れない記号（ {$I[1]}, {$O[1]} ）が現れています。

Action
awk '{ print $1*2 }' {$I[1]} > {$O[1]}
End

{$I[1]}は入力ファイル、{$O[1]}は出力ファイルを表しています。それぞれの[]の中の数字１は、input/outputで定義したそれぞれの１番目ということを意味しています。 
次の基本３での複数ファイルの入出力では１以外が使われることになります。 
まだ、何が便利か少し分かりづらいと思いますが、例えば、Multiplying2.pioneとして、次のように記述するとどのように動作するでしょうか。

Rule Main
input 'test.in'
output '{$I[1]}.out'

Action
awk '{ print $1*2 }' {$I[1]} > {$O[1]}
End

少し考えてみて下さい。そして、動作させてみましょう。

$ pione-client Multiplying2.pione -b MultiplyingOutput -i MultiplyingInput/

MultiplyingOutput/outputのディレクトリにはどんなファイルができあがったでしょうか。 
そうですね。test.in.outができあがっています。何故かを考えてみましょう。

=== 基本３（複数ファイルの入力と複数ファイルの出力）===

　さて、更新判定が理解できたところで、複数ファイルの入出力について考えてみましょう。 
test1.in, test2.inから、それぞれ２倍した数が格納された、test1.out, test2.outが出力できる[[PIONE定義書]]を作成してみましょう。 
ここで、名前をMultiplyingFiles.pioneとして作成してみましょう。
-----

　問題１：上記のMultiplyingFiles.pioneを作成して実行してみて下さい。

-----

　解答例１：

Rule Main
input 'test1.in'
input 'test2.in'
output 'test1.out'
output 'test2.out'

Action
awk '{ print $1*2 }' {$I[1]} > {$O[1]}
awk '{ print $1*2 }' {$I[2]} > {$O[2]}
End

-----

このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic3 こちら]からダウンロードできます。 
どうでしょうか。思ったように動きましたか。複数のファイルがあれば、複数書き並べればよいのです。

　でもなんだか、同じ事をするのに、同じような行を何行も書くのは嫌だなと思いませんか。もし、２倍を５倍に変えたくなったら全ての行を書き換えなくてはなりません。 
１０行ぐらいならそれでもよいけれど、１００個、１０００個とファイルが増えてきたらどうでしょうか。だんだん嫌になってきませんか。 

　では、どうすれば良いでしょうか。例えば、シェルスクリプトが得意なひとは次の様なプログラムを設定することも出来ます。

-----

　解答例２：

Rule Main
input 'test1.in'
input 'test2.in'
output 'test1.out'
output 'test2.out'

Action
for i in `ls *.in`; do
awk '{ print $1*2 }' $i > `basename $i .in`.out
done
End

-----

これでも、ファイルが増えるたびにinput/outputを書き換える必要があります。 
そこで、全てのファイルを入力し、全てのファイルを出力するように入出力を表現することも出来ます。

-----

　解答例３：

Rule Main
input '*.in'.all
output '*.out'.all

Action
for i in `ls *.in`; do
awk '{ print $1*2 }' $i > `basename $i .in`.out
done
End

-----

どうでしょうか。うまく動作したでしょうか。ここで、

input '*.in'.all
output '*.out'.all

の部分は、*は任意の文字列を表現します。つまり、*.inは、ファイルの最後が.inで終了しているファイル全て、*.outは、ファイルの最後が.outで終了しているファイル全てを表します。 
.allがついていると、全てのファイルを取り扱うことを意味しています。 
.allが付いていないときには、.eachがついていることがdefaultとして決まっています。一つひとつのファイルを別々に実行するという意味になります。 
これでずいぶんと記述しやすくなりました。

　でも、これだと、*.inのどれかのファイルが更新されていると全て変更になってしまいます。試してみて下さい。なんだか無駄ですね。 
また、同時にできるはずのことをfor文を使って順次実行しているので、時間も無駄ですね。このくらいのタスクであれば、たいして時間がかかるわけではないのですが、もっと時間のかかるタスクだったらどうでしょうか。 
必要なファイルの更新だけを、できれば複数のホストや一台でもマルチコアＣＰＵを使って、同時に動かすともっと早く終了できるようになるはずです。

　さて、それではどのようにすればよいのでしょうか。それが次の基本４になります。だんだんPIONEらしくなってきます。

=== 基本４（複数ファイルの入力と複数ファイルの出力の並列処理）===

　次は、さっきと違ってallが付いていません。なにが起きるかを考えてみましょう。

Rule Main
input '*.in'
output '{$I[1][1]}.out'
Action
awk '{ print $1*2 }' {$I[1]} > {$O[1]}
End

このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic4 こちら]からダウンロードできます。 
ここで、{$I[1][1]}.outは1番目のinputで拡張子を除いたファイル名を指します。（参照: [[PIONE定義書#入力定義]]） 
下は実行した例です。

$ pione-client MultiplyingFilesEach.pione -b MultiplyingFilesEachOutput -i MultiplyingFilesInput/ -t 4
==> &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
>>> &Anonymous:Main([test1.in],{})
>>> &Anonymous:Main([test2.in],{})
>>> &Anonymous:Main([test3.in],{})
>>> &Anonymous:Main([test4.in],{})
>>> &Anonymous:Main([test5.in],{})
>>> &Anonymous:Main([test6.in],{})
>>> &Anonymous:Main([test7.in],{})
==> &Anonymous:Main([test1.in],{})
==> &Anonymous:Main([test2.in],{})
==> &Anonymous:Main([test3.in],{})
==> &Anonymous:Main([test4.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Main([test2.in],{})
<== &Anonymous:Main([test1.in],{})
<== &Anonymous:Main([test3.in],{})
<== &Anonymous:Main([test4.in],{})
==> &Anonymous:Main([test5.in],{})
==> &Anonymous:Main([test6.in],{})
==> &Anonymous:Main([test7.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Main([test6.in],{})
<== &Anonymous:Main([test5.in],{})
<== &Anonymous:Main([test7.in],{})
<-- Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<-- Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Root([test1.in,test2.in,test3.in,...],{})

４つのタスクが並列に動いている様子が分かるでしょうか。 
確かに４つずつのタスク( ==> &Anonymous:Main([testN.in],{}))が並列に動作しているようです。 
もう一度実行してみると下のようになります。

$ pione-client MultiplyingFilesEach.pione -b MultiplyingFilesEachOutput -i MultiplyingFilesInput/ -t 4
==> &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<-- Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Root([test1.in,test2.in,test3.in,...],{})

今度は実行されません。そこで、ひとつファイルを更新してみます。

$ touch MultiplyingFilesInput/test3.in
$ pione-client MultiplyingFilesEach.pione -b MultiplyingFilesEachOutput -i MultiplyingFilesInput/ -t 4
==> &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
>>> &Anonymous:Main([test3.in],{})
==> &Anonymous:Main([test3.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Main([test3.in],{})
<-- Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<-- Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Root([test1.in,test2.in,test3.in,...],{})

となり、test3.inだけが更新されているのが分かります。これがeachとしての振る舞いです。 

====[[基本４の補足（eachでの速度検証）]]====
eachを使った並列化処理による計算速度向上の一例を示しています。 

=== 基本５（直列：フロールールの設定）===

　さて、もう少し複雑なルールについて設定してみましょう。 
まず、ふたつのルールを組み合わせて、並列計算することを考えてみます。

Rule Main
input '*.in'
output '*.out'
Flow
rule First
rule Second
End

Rule First
input '*.in'
output '{$I[1][1]}.route'
Action
awk '{ print $1*2 }' {$I[1]} > {$O[1]}
End

Rule Second
input '*.route'
output '{$I[1][1]}.out'
Action
awk '{ print $1+1 }' {$I[1]} > {$O[1]}
End

このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic5 こちら]からダウンロードできます。

　実行結果を以下に示します。最初に５つのタスク(First)が並列で動いているのがわかります。 
その後、終了した順に、次のルールが動いています。

$ pione-client Serial2.pione -i SerialInput/ -b Serial2Output
==> &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
>>> &Anonymous:Main([test1.in],{})
>>> &Anonymous:Main([test2.in],{})
>>> &Anonymous:Main([test3.in],{})
>>> &Anonymous:Main([test4.in],{})
>>> &Anonymous:Main([test5.in],{})
==> &Anonymous:Main([test1.in],{})
--> Rule Application: &Anonymous:Main([test1.in],{})
--> Distribution: &Anonymous:Main([test1.in],{})
>>> &Anonymous:First([test1.in],{})
==> &Anonymous:Main([test2.in],{})
--> Rule Application: &Anonymous:Main([test2.in],{})
--> Distribution: &Anonymous:Main([test2.in],{})
>>> &Anonymous:First([test2.in],{})
==> &Anonymous:Main([test3.in],{})
--> Rule Application: &Anonymous:Main([test3.in],{})
--> Distribution: &Anonymous:Main([test3.in],{})
>>> &Anonymous:First([test3.in],{})
==> &Anonymous:Main([test4.in],{})
--> Rule Application: &Anonymous:Main([test4.in],{})
--> Distribution: &Anonymous:Main([test4.in],{})
>>> &Anonymous:First([test4.in],{})
==> &Anonymous:Main([test5.in],{})
--> Rule Application: &Anonymous:Main([test5.in],{})
--> Distribution: &Anonymous:Main([test5.in],{})
>>> &Anonymous:First([test5.in],{})
==> &Anonymous:First([test1.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:First([test1.in],{})
<-- Distribution: &Anonymous:Main([test1.in],{})
--> Distribution: &Anonymous:Main([test1.in],{})
>>> &Anonymous:Second([test1.route],{})
==> &Anonymous:First([test2.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:First([test2.in],{})
<-- Distribution: &Anonymous:Main([test2.in],{})
--> Distribution: &Anonymous:Main([test2.in],{})
>>> &Anonymous:Second([test2.route],{})
==> &Anonymous:First([test3.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:First([test3.in],{})
<-- Distribution: &Anonymous:Main([test3.in],{})
--> Distribution: &Anonymous:Main([test3.in],{})
>>> &Anonymous:Second([test3.route],{})
==> &Anonymous:First([test4.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:First([test4.in],{})
<-- Distribution: &Anonymous:Main([test4.in],{})
--> Distribution: &Anonymous:Main([test4.in],{})
>>> &Anonymous:Second([test4.route],{})
==> &Anonymous:First([test5.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:First([test5.in],{})
<-- Distribution: &Anonymous:Main([test5.in],{})
--> Distribution: &Anonymous:Main([test5.in],{})
>>> &Anonymous:Second([test5.route],{})
==> &Anonymous:Second([test1.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Second([test1.route],{})
<-- Distribution: &Anonymous:Main([test1.in],{})
<-- Rule Application: &Anonymous:Main([test1.in],{})
<== &Anonymous:Main([test1.in],{})
==> &Anonymous:Second([test2.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Second([test2.route],{})
<-- Distribution: &Anonymous:Main([test2.in],{})
<-- Rule Application: &Anonymous:Main([test2.in],{})
<== &Anonymous:Main([test2.in],{})
==> &Anonymous:Second([test3.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Second([test3.route],{})
<-- Distribution: &Anonymous:Main([test3.in],{})
<-- Rule Application: &Anonymous:Main([test3.in],{})
<== &Anonymous:Main([test3.in],{})
==> &Anonymous:Second([test4.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Second([test4.route],{})
<-- Distribution: &Anonymous:Main([test4.in],{})
<-- Rule Application: &Anonymous:Main([test4.in],{})
<== &Anonymous:Main([test4.in],{})
==> &Anonymous:Second([test5.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Second([test5.route],{})
<-- Distribution: &Anonymous:Main([test5.in],{})
<-- Rule Application: &Anonymous:Main([test5.in],{})
<-- Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Main([test5.in],{})
<-- Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Root([test1.in,test2.in,test3.in,...],{})

一度、終了しましたので、次は実行されません。

$ pione-client Serial2.pione -i SerialInput/ -b Serial2Output
==> &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<-- Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Root([test1.in,test2.in,test3.in,...],{})

さて、ここで、ファイルをひとつ(test6.in)増やしてみましょう。

$ pione-client Serial2.pione -i SerialInput/ -b Serial2Output
==> &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
>>> &Anonymous:Main([test6.in],{})
==> &Anonymous:Main([test6.in],{})
--> Rule Application: &Anonymous:Main([test6.in],{})
--> Distribution: &Anonymous:Main([test6.in],{})
>>> &Anonymous:First([test6.in],{})
==> &Anonymous:First([test6.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' test6.in > test6.route
SH ------------------------------------------------------------
<== &Anonymous:First([test6.in],{})
<-- Distribution: &Anonymous:Main([test6.in],{})
--> Distribution: &Anonymous:Main([test6.in],{})
>>> &Anonymous:Second([test6.route],{})
==> &Anonymous:Second([test6.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' test6.route > test6.out
SH ------------------------------------------------------------
<== &Anonymous:Second([test6.route],{})
<-- Distribution: &Anonymous:Main([test6.in],{})
<-- Rule Application: &Anonymous:Main([test6.in],{})
<-- Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Main([test6.in],{})
--> Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<-- Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<-- Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Root([test1.in,test2.in,test3.in,...],{})

新しくできたファイルだけが作られていることがわかります。 
それでは、ファイルの更新がかかったときはどうなるでしょうか。test2.inをtouchコマンドで更新してみました。

$ touch SerialInput/test2.in
$ pione-client Serial2.pione -i SerialInput/ -b Serial2Output2
==> &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
--> Rule Application: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
--> Distribution: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
>>> &Anonymous:Main([test2.in],{})
>>> &Anonymous:Main([test6.in],{})
==> &Anonymous:Main([test2.in],{})
--> Rule Application: &Anonymous:Main([test2.in],{})
--> Distribution: &Anonymous:Main([test2.in],{})
>>> &Anonymous:First([test2.in],{})
==> &Anonymous:Main([test6.in],{})
--> Rule Application: &Anonymous:Main([test6.in],{})
<-- Rule Application: &Anonymous:Main([test6.in],{})
<== &Anonymous:Main([test6.in],{})
==> &Anonymous:First([test2.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' test2.in > test2.route
SH ------------------------------------------------------------
<== &Anonymous:First([test2.in],{})
<-- Distribution: &Anonymous:Main([test2.in],{})
--> Distribution: &Anonymous:Main([test2.in],{})
>>> &Anonymous:Second([test2.route],{})
==> &Anonymous:Second([test2.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' test2.route > test2.out
SH ------------------------------------------------------------
<== &Anonymous:Second([test2.route],{})
<-- Distribution: &Anonymous:Main([test2.in],{})
<-- Rule Application: &Anonymous:Main([test2.in],{})
<-- Distribution: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
<== &Anonymous:Main([test2.in],{})
--> Distribution: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
>>> &Anonymous:Main([test6.in],{})
==> &Anonymous:Main([test6.in],{})
--> Rule Application: &Anonymous:Main([test6.in],{})
<-- Rule Application: &Anonymous:Main([test6.in],{})
<== &Anonymous:Main([test6.in],{})
<-- Distribution: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
--> Distribution: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
<-- Distribution: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
<-- Rule Application: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
<== &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})

となり、新しいファイルであるtest2.in, test6.inに関しては、変更の可能性があるので起動し始めます。 
しかし、実際にinputファイルが更新されたtest2.inのみ処理が行われ、test2.outのみ作成されます。 

====[[基本５の補足（並列処理での速度向上例）]]====
基本5のプログラムに関して速度向上の例を示しています。 

=== 基本６（パラメータの定義） ===
　入力データは、ファイルから読み取る以外にパラメータとして使用する方法があります。 
パラメータにはbasicとadvancedの２つがあります。処理上の違いは特にありませんが、前者を基本パラメータ、後者を上級者向けパラメータとして定義することで[[ユーザ]]のレベルに応じて変更可能なパラメータを区別することができます。 
下記のように定義します。（参照：[[PIONE定義書#パラメータ定義]]） 

<pre>
param $val := 123
basic param $b_val := 456
advanced param $a_val := 987

Basic Param
$b_val1 := 135
$b_val2 := 246
End

Advanced Param
$a_val1 := 975
$a_val2 := 864
End

Rule Main
output 'message.txt'
param $main_val := $val * 10
Flow
rule Sub {sub_val1: $main_val}
End

Rule Sub
output 'message.txt'
param $sub_val1
param $sub_val2 := $val * 100
Action
echo "Basic Parameters:" > {$O[1]};
echo " val: {$val}" >> {$O[1]};
echo " b_val: {$b_val}" >> {$O[1]};
echo " b_val1: {$b_val1}" >> {$O[1]};
echo " b_val2: {$b_val2}" >> {$O[1]};
echo "Advanced Parameters:" >> {$O[1]};
echo " a_val: {$a_val}" >> {$O[1]};
echo " a_val1: {$a_val1}" >> {$O[1]};
echo " a_val2: {$a_val2}" >> {$O[1]};
echo "Parameters in Sub:" >> {$O[1]};
echo " sub_val1: {$sub_val1}" >> {$O[1]};
echo " sub_val2: {$sub_val2}" >> {$O[1]};
End
</pre>
１つずつ定義するときはそれぞれbasic param XXX、advanced param YYYのように記述します。（単にparam ZZZとしたときはbasic扱いとなります。） 
まとめて定義したいときはBasic Param ~ End, Advanced Param ~ Endで囲みます。 
定義する変数名の先頭には'''$'''を付けて記述し、''':='''にてデフォルト値を定義することができます。 
またAction内で使用するときは入力ファイルや出力ファイルと同様に'''{''' '''}'''で括ります。 

設定したパラメータはオプション--params="{XXX:N}"で値を設定して実行します。 
また、定義書内でデフォルト値を記述しておけば、--params内で設定しなかったパラメータもデフォルト値で処理されます。 

今回はbasicのみに値を設定して実行してみます。 
<pre>
/Basic6$ pione-client ParamEcho.pione -b ParamEcho --params="{val:1,b_val:3,b_val1:5,b_val2:7}"
"{val:1,b_val:3,b_val1:5,b_val2:7}"
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{main_val:(10)})
==> &Anonymous:Main([],{main_val:(10)})
--> Rule Application: &Anonymous:Main([],{main_val:(10)})
--> Distribution: &Anonymous:Main([],{main_val:(10)})
>>> &Anonymous:Sub([],{sub_val1:(10),sub_val2:(100)})
==> &Anonymous:Sub([],{sub_val1:(10),sub_val2:(100)})
SH ------------------------------------------------------------
SH echo "Basic Parameters:" > message.txt;
SH echo " val: 1" >> message.txt;
SH echo " b_val: 3" >> message.txt;
SH echo " b_val1: 5" >> message.txt;
SH echo " b_val2: 7" >> message.txt;
SH echo "Advanced Parameters:" >> message.txt;
SH echo " a_val: 987" >> message.txt;
SH echo " a_val1: 975" >> message.txt;
SH echo " a_val2: 864" >> message.txt;
SH echo "Parameters in Sub:" >> message.txt;
SH echo " sub_val1: 10" >> message.txt;
SH echo " sub_val2: 100" >> message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Sub([],{sub_val1:(10),sub_val2:(100)})
<-- Distribution: &Anonymous:Main([],{main_val:(10)})
<-- Rule Application: &Anonymous:Main([],{main_val:(10)})
<-- Distribution: &Anonymous:Root([],{})
<== &Anonymous:Main([],{main_val:(10)})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
/Basic6$ cat ParamEcho/output/message.txt
Basic Parameters:
val: 1
b_val: 3
b_val1: 5
b_val2: 7
Advanced Parameters:
a_val: 987
a_val1: 975
a_val2: 864
Parameters in Sub:
sub_val1: 10
sub_val2: 100
/Basic6$
</pre>
設定を反映した処理が実行できました。 

==== パラメータのシーケンス ====
　ではパラメータの値を複数（シーケンス）使用した場合はどうなるのでしょうか。 
valに複数の値(1|2)を入れてみます。（参照：[[PIONEの式#シーケンス]]） 

<pre>
/Basic6$ pione-client ParamEcho.pione -b ParamEcho --params="{val:(1|2)}"
"{val:(1|2)}"
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{main_val:(10)})
>>> &Anonymous:Main([],{main_val:(20)})
==> &Anonymous:Main([],{main_val:(10)})
--> Rule Application: &Anonymous:Main([],{main_val:(10)})
--> Distribution: &Anonymous:Main([],{main_val:(10)})
>>> &Anonymous:Sub([],{sub_val1:(10),sub_val2:(100)})
>>> &Anonymous:Sub([],{sub_val1:(10),sub_val2:(200)})
==> &Anonymous:Main([],{main_val:(20)})
--> Rule Application: &Anonymous:Main([],{main_val:(20)})
--> Distribution: &Anonymous:Main([],{main_val:(20)})
>>> &Anonymous:Sub([],{sub_val1:(20),sub_val2:(100)})
>>> &Anonymous:Sub([],{sub_val1:(20),sub_val2:(200)})
==> &Anonymous:Sub([],{sub_val1:(10),sub_val2:(100)})
SH ------------------------------------------------------------
SH echo "Basic Parameters:" > message.txt;
SH echo " val: 1 2" >> message.txt;
SH echo " b_val: 456" >> message.txt;
SH echo " b_val1: 135" >> message.txt;
SH echo " b_val2: 246" >> message.txt;
SH echo "Advanced Parameters:" >> message.txt;
SH echo " a_val: 987" >> message.txt;
SH echo " a_val1: 975" >> message.txt;
SH echo " a_val2: 864" >> message.txt;
SH echo "Parameters in Sub:" >> message.txt;
SH echo " sub_val1: 10" >> message.txt;
SH echo " sub_val2: 100" >> message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Sub([],{sub_val1:(10),sub_val2:(100)})
==> &Anonymous:Sub([],{sub_val1:(10),sub_val2:(200)})
SH ------------------------------------------------------------
SH echo "Basic Parameters:" > message.txt;
SH echo " val: 1 2" >> message.txt;
SH echo " b_val: 456" >> message.txt;
SH echo " b_val1: 135" >> message.txt;
SH echo " b_val2: 246" >> message.txt;
SH echo "Advanced Parameters:" >> message.txt;
SH echo " a_val: 987" >> message.txt;
SH echo " a_val1: 975" >> message.txt;
SH echo " a_val2: 864" >> message.txt;
SH echo "Parameters in Sub:" >> message.txt;
SH echo " sub_val1: 10" >> message.txt;
SH echo " sub_val2: 200" >> message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Sub([],{sub_val1:(10),sub_val2:(200)})
<-- Distribution: &Anonymous:Main([],{main_val:(10)})
<-- Rule Application: &Anonymous:Main([],{main_val:(10)})
<== &Anonymous:Main([],{main_val:(10)})
==> &Anonymous:Sub([],{sub_val1:(20),sub_val2:(100)})
SH ------------------------------------------------------------
SH echo "Basic Parameters:" > message.txt;
SH echo " val: 1 2" >> message.txt;
SH echo " b_val: 456" >> message.txt;
SH echo " b_val1: 135" >> message.txt;
SH echo " b_val2: 246" >> message.txt;
SH echo "Advanced Parameters:" >> message.txt;
SH echo " a_val: 987" >> message.txt;
SH echo " a_val1: 975" >> message.txt;
SH echo " a_val2: 864" >> message.txt;
SH echo "Parameters in Sub:" >> message.txt;
SH echo " sub_val1: 20" >> message.txt;
SH echo " sub_val2: 100" >> message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Sub([],{sub_val1:(20),sub_val2:(100)})
==> &Anonymous:Sub([],{sub_val1:(20),sub_val2:(200)})
SH ------------------------------------------------------------
SH echo "Basic Parameters:" > message.txt;
SH echo " val: 1 2" >> message.txt;
SH echo " b_val: 456" >> message.txt;
SH echo " b_val1: 135" >> message.txt;
SH echo " b_val2: 246" >> message.txt;
SH echo "Advanced Parameters:" >> message.txt;
SH echo " a_val: 987" >> message.txt;
SH echo " a_val1: 975" >> message.txt;
SH echo " a_val2: 864" >> message.txt;
SH echo "Parameters in Sub:" >> message.txt;
SH echo " sub_val1: 20" >> message.txt;
SH echo " sub_val2: 200" >> message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Sub([],{sub_val1:(20),sub_val2:(200)})
<-- Distribution: &Anonymous:Main([],{main_val:(20)})
<-- Rule Application: &Anonymous:Main([],{main_val:(20)})
<-- Distribution: &Anonymous:Root([],{})
<== &Anonymous:Main([],{main_val:(20)})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
/Basic6$
</pre>
デフォルトではval=(1|2)がeachとして動作します。この場合はmain_val=(10|20)となって、それぞれsub_val1=(10|20), sub_val2=(100|200)となります。 
このとき、sub_val1, sub_val2はともにeachですので、上記のように(10, 100), (10, 200), (20, 100), (20, 200)と2*2の組み合わせでルールが動きます。 

では、val=(1|2).allではどうなるでしょうか。 

<pre>
/Basic6$ pione-client ParamEcho.pione -b ParamEcho --params="{val:(1|2).all}"
"{val:(1|2).all}"
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{main_val:(10|20)})
==> &Anonymous:Main([],{main_val:(10|20)})
--> Rule Application: &Anonymous:Main([],{main_val:(10|20)})
--> Distribution: &Anonymous:Main([],{main_val:(10|20)})
>>> &Anonymous:Sub([],{sub_val1:(10|20),sub_val2:(100|200)})
==> &Anonymous:Sub([],{sub_val1:(10|20),sub_val2:(100|200)})
SH ------------------------------------------------------------
SH echo "Basic Parameters:" > message.txt;
SH echo " val: 1 2" >> message.txt;
SH echo " b_val: 456" >> message.txt;
SH echo " b_val1: 135" >> message.txt;
SH echo " b_val2: 246" >> message.txt;
SH echo "Advanced Parameters:" >> message.txt;
SH echo " a_val: 987" >> message.txt;
SH echo " a_val1: 975" >> message.txt;
SH echo " a_val2: 864" >> message.txt;
SH echo "Parameters in Sub:" >> message.txt;
SH echo " sub_val1: 10 20" >> message.txt;
SH echo " sub_val2: 100 200" >> message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Sub([],{sub_val1:(10|20),sub_val2:(100|200)})
<-- Distribution: &Anonymous:Main([],{main_val:(10|20)})
<-- Rule Application: &Anonymous:Main([],{main_val:(10|20)})
<== &Anonymous:Main([],{main_val:(10|20)})
<-- Distribution: &Anonymous:Root([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
/Basic6$
</pre>
allの場合はsub_val1=(10|20), sub_val2=(100|200)として組み合わせるので、上記のように１つのルールが動くだけです。 
このようにパラメータについてもeach, allを使うことでルールの振り分けが可能です。 

=== 基本７（条件文） ===
==== if文 ====
　今回はif文などを用いて実行したいルールを制御してみましょう。 

<pre>
param $val := 123

Rule Main
output 'message.txt'
Flow
if $val % 2 == 0
rule Even
else
rule Odd
end
End

Rule Even
output 'message.txt'
Action
echo "{$val} is even." > message.txt;
End

Rule Odd
output 'message.txt'
Action
echo "{$val} is odd." > message.txt;
End
</pre>

このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic7 こちら]からダウンロードできます。 
最初のパラメータvalに対して、偶数の場合と奇数の場合でそれぞれ別のルールを実行するようにしています。 
Rule Mainにif文がありますが、[[PIONE]]の記述ではif ~ endと記述します。 

では、valをデフォルト値で実行してみましょう。 

<pre>
/Basic7$ pione-client EvenOdd.pione -b EvenOdd
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{})
==> &Anonymous:Main([],{})
--> Rule Application: &Anonymous:Main([],{})
--> Distribution: &Anonymous:Main([],{})
>>> &Anonymous:Odd([],{})
==> &Anonymous:Odd([],{})
SH ------------------------------------------------------------
SH echo "123 is odd." > message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Odd([],{})
<-- Distribution: &Anonymous:Main([],{})
<-- Rule Application: &Anonymous:Main([],{})
<-- Distribution: &Anonymous:Root([],{})
<== &Anonymous:Main([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
/Basic7$ cat EvenOdd/output/message.txt
123 is odd.
/Basic7$
</pre>

val=123で定義されていますので、この場合は奇数のルールが動いているのが分かります。 

次にvalを偶数にして実行してみます。 

<pre>
/Basic7$ pione-client EvenOdd.pione -b EvenOdd --params="{val:456}"
"{val:456}"
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{})
==> &Anonymous:Main([],{})
--> Rule Application: &Anonymous:Main([],{})
--> Distribution: &Anonymous:Main([],{})
>>> &Anonymous:Even([],{})
==> &Anonymous:Even([],{})
SH ------------------------------------------------------------
SH echo "456 is even." > message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Even([],{})
<-- Distribution: &Anonymous:Main([],{})
<-- Rule Application: &Anonymous:Main([],{})
<-- Distribution: &Anonymous:Root([],{})
<== &Anonymous:Main([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
/Basic7$ cat EvenOdd/output/message.txt
456 is even.
/Basic7$
</pre>

偶数のルールが動きます。 

以上のようにして条件に合わせてルールを制御することができます。 

==== case文 ====
　case文の場合は下記のように記述します。 

<pre>
case $val % 2
when 0
rule Even
else
rule Odd
end
</pre>

==== constraint ====
　constraintを使用して下記のように記述する方法もあります。 

<pre>
param $val := 123

Rule Main
output 'message.txt'
Flow
rule Even
rule Odd
End

Rule Even
output 'message.txt'
constraint $val % 2 == 0
Action
echo "{$val} is even." > {$O[1]};
End

Rule Odd
output 'message.txt'
constraint $val % 2 == 1
Action
echo "{$val} is odd." > {$O[1]};
End
</pre>

====[[デバッグのための条件文]]====
　条件文を使って、デバッグの切り替えの手間が少なくなる方法を考えてみましょう。 
 

=== 基本８（インタラクティブ操作） ===
　ここまでは、コマンドを実行すると結果出力までの動作を全てプログラムに委ねる、一方通行の処理を記述してきました。 
次は、処理の途中でユーザが操作できるようにし、それ以降の処理を制御(インタラクティブ操作)できるようにしてみましょう。 

今回はウェブページから選択した入力ファイルに対して、設定した演算子(+, *)、数値で計算したファイルを出力する処理を作成します。 
実行ファイル作成のためにパッケージを、実行のために[[PIONE Webclient]]を利用します。 

まず、インタラクティブ操作のための処理を[[PIONE定義書]]に記述します。 

<pre>
.@ PackageName :: "InteractiveCalc"

Rule Main
output '*.out'.all
Flow
rule Interaction
End

Rule Interaction
output '*.out'.all
Action
# build public directory for pione-interactive
mkdir public
cp etc/* public
cp bin/* public

echo "Interruption!" > result.log.out

# start interactive operation
pione-interactive browser --public public

cp public/* .
echo "finish!" > result.log.out
End
</pre>

この処理では、.outファイルを出力ファイルとしてダウンロードできるようにしています。 
[[pione-interactive]] browserコマンドにてInteractiveページを開けるようにします。 
このとき、--publicオプションで、ページのために使用する[[html]]ファイルや[[cgi]]ファイルなどがあるディレクトリを指定します。 
そのために、事前にディレクトリ(public)を用意し、そのディレクトリの下に、etcディレクトリ内とbinディレクトリ内のすべてのファイルをそれぞれコピーしています。 
また、Interactiveページを終了した後は、作成したファイルを処理できるようにpublicディレクトリ内のデータを全てワークスペース(.)へコピーしています。 

次に、ウェブページにて最初に呼び出されるindex.htmlを作成します。htmlファイルはetcディレクトリ内に置きます。 

<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>InteractiveCalc Index Page</title>
</head>
<body>
<form action="FileCalc.cgi" method="post" enctype="multipart/form-data">
入力ファイル名
<input type="file" name="inputfile"/>
 
演算子
<select name="operator">
<option value="add">+</option>
<option value="mul">*</option>
</select>
数値
<input type="text" name="value"/>
 
出力ファイル名
<input type="text" name="outputfile"/>
 
<button type="submit">計算開始</button>
</form>
 
 
<a href="?pione-action=finish">終了</a>
</body>
</html>
</pre>

最後の方にある<a href="?pione-action=finish">終了</a>は、「終了」をクリックするとワーキンングディレクトリに終了通知を行い、インタラクティブ操作を終了させる処理です。詳しくは[[インタラクションAPI]]をご覧下さい。 

そして、.cgiファイルを作成します。[[シェルスクリプト]]や[[Eosのコマンド]]などの特殊な処理はこのファイルに記述します。 
cgiファイルはbinディレクトリ内に置きます。 

<pre>
#!/usr/bin/env ruby

require 'cgi'

cgi = CGI.new

HTMLstr=""

# Main Process

## Query to Parameters
input_file=cgi.params['inputfile'][0]
output_path=cgi['outputfile']
operator=cgi['operator']
value=cgi['value'].to_i

## Calc input to output
output_file = open(output_path, "w")

HTMLstr += "<table>"
HTMLstr += "<tr>"
HTMLstr += "<td>" + input_file.original_filename.to_s + "</td>"
HTMLstr += "<td>" + output_path + "</td>"
HTMLstr += "</tr>"

input_file.each do |input_line|
HTMLstr += "<tr>"
HTMLstr += "<td>" + input_line + "</td>"

work_value = input_line.to_i

case operator
when "add"
work_value += value
when "mul"
work_value *= value
end

output_line = work_value.to_s
output_file.write(output_line + "\n")
HTMLstr += "<td>" + output_line + "</td>"
HTMLstr += "</tr>"
end

HTMLstr += "</table>"
output_file.close

# Output as html
cgi.out(type: "text/html") do
HTMLstr
end
</pre>

今回は[[Ruby]]を使って記述しています。# Output as html以下のコードで[[html]]形式に変換するようにしています。そのためにCGIクラスが必要なので、require 'cgi'とcgi = CGI.newで用意しています。このようにすると、# Main Process内のようにHTMLstrに記述する文字列を加えるだけで、自由な処理を行ってその結果を[[html]]のページを表示することができます。また、## Query to ParametersにてPOST形式のクエリを変数に変換していますが、typeがfileの場合、ファイル本体はCGIクラスメンバーParamsから受け取ります。このとき受け取るデータはファイルポインタ配列ですので、取得したい要素No.を指定する必要があります。今回、入力ファイルは１つしか格納していないので、cgi.params['inputfile'][0]となります。 

コードが完成したら、[[パッケージ作成]]を行います。([[PIONEチュートリアル-package]]を参照) 
なお、これらのファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic8 こちら]からダウンロードできます。 

<pre>
/PIONE$ pione package build Basic8/
info: update the package info file: local:/Eos/tutorial/SampleCode/PIONE/Basic8/pione-package.json
info: Package local:/Eos/tutorial/SampleCode/PIONE/InteractiveCalc.ppg has been built successfully.
</pre>

作成した[[パッケージ]]は[[PIONE Webclient]]にて動かすことができます。[[PIONE Webclientチュートリアル#インタラクティブ操作を含むコマンドを実行]]にて動作方法と実行結果を記載しています。 
 
index.htmlとFileCalc.cgiで作成したページ 
<table>
<tr>
<td>[[画像:PIONE-Webclient13.png|border]]</td>
<td>-></td>
<td>[[画像:PIONE-Webclient14.png|border]]</td>
</tr>
</table>
 

=== 基本９（[[インタラクションAPI]]の使用） ===
　[[インタラクションAPI]]を使用してワーキングディレクトリに通知を送ることで、ファイル操作や終了などを命令することができます。.htmlや.cgiに記述することにより、[[ユーザ]]からの操作を受けてこれらの命令を実行することができます。 
 

Annotation.pione
<pre>
.@ PackageName :: "FileOperation"
.@ Editor :: "Kinoshita"
.@ Tag :: "v0.1.0"
</pre>
 

Main.pione 

<pre>
Rule Main
output '*.txt'.all
Flow
rule Interaction
End
</pre>

今回は.txtファイルのみを出力するようにしています。 

Interaction.pione
<pre>
Rule Interaction
output '*.*'.all
Action
# build public directory for pione-interactive
mkdir public
cp etc/* public
cp bin/* public

# start interactive operation
pione-interactive browser --public public

cp public/* .
End
</pre>

etc/index.html 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>FileOperation</title>
</head>
<body>
<form action="./AAA.txt" method="post" enctype="multipart/form-data">
<input type="hidden" name="pione-action" value="create"/>
<button type="submit">作成（ファイル）</button>
<input type="file" name="pione-content" value=""/>
</form>
<form action="./AAA.txt" method="post" enctype="multipart/form-data">
<input type="hidden" name="pione-action" value="create"/>
<button type="submit">作成（テキスト）</button>
<input type="text" name="pione-content" value=""/>
</form>
<form action="./AAA.txt" method="post" enctype="multipart/form-data">
<input type="hidden" name="pione-action" value="delete"/>
<button type="submit">削除</button>
</form>
<form action="./list.cgi" method="post" enctype="multipart/form-data">
<input type="hidden" name="pione-action" value="get"/>
<button type="submit">ファイル一覧の取得</button>
</form>
 
 
<a href="?pione-action=finish">終了</a>
</body>
</html>
</pre>

それぞれのボタンよりファイル操作を行います。 
<table>
<tr>
<td>作成（ファイル）：</td>
<td>指定したファイルをサーバ上のファイル(AAA.txt)に書き込んでアップロードします。</td>
</tr>
<tr>
<td>作成（テキスト）：</td>
<td>指定したテキストボックスの内容でサーバ上のファイル(AAA.txt)に書き込みます。</td>
</tr>
<tr>
<td>削除：</td>
<td>サーバ上のファイル(AAA.txt)内容を削除します。</td>
</tr>
<tr>
<td>ファイル一覧の取得：</td>
<td>サーバ上のファイル一覧を表示します。(list.cgiが動作します)</td>
</tr>
<tr>
<td>終了：</td>
<td>操作を終了します。</td>
</tr>
</table>

etc/list.cgi 
<pre>
#!/usr/bin/env ruby

require 'cgi'

cgi = CGI.new

strHTML = ""

strHTML += <<'Block-HTML'
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>CGIページ</title>
</head>
<body>
<script src="http://code.jquery.com/jquery-1.11.1.min.js"></script>
<div id="textDiv"></div>
<script type="text/javascript">
var div = document.getElementById("textDiv");
div.textContent = "";
$.getJSON("./", {"pione-action": "list"}, function(data){
$.each(data, function(file) {
div.textContent += this.name +"\n";
});
});
</script>
<a href="Index.html">戻る</a>
 
 
<a href="?pione-action=finish">終了</a>
</body>
</html>
Block-HTML

# Output as html
cgi.out(type: "text/html") do
strHTML
end
</pre>

"./"に対して"pione-action=list"を送信したときの戻り値をgetJSONにより取得して、データ毎の"name"を出力するようにしています。 

これらのファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic9 こちら]からダウンロードできます。 
では、実行させてみましょう。 

インタラクションページを開くと下記のようになっています。 
[[画像:Outdata-PIONE-Basic9-1.png|border]] 

まずは選択...ボタンからテキストファイルを選択し、作成（ファイル）ボタンでサーバ内にファイルを作成（アップロード）してみましょう。 
[[画像:Outdata-PIONE-Basic9-2.png|border]] 
これによりAAA.txtが同じ内容で作成(アップロード)されます。終了した後にダウンロードすると/output/AAA.txtの内容を確認できます。 

また、ファイル一覧の取得ボタンよりサーバ上のファイル一覧を閲覧することができます。 
[[画像:Outdata-PIONE-Basic9-3.png|border]] 
AAA.txtが確認できます。 

そして削除ボタンを押すと、AAA.txtを削除します。 
[[画像:Outdata-PIONE-Basic9-4.png|border]] 
AAA.txtがなくなっているのが確認できます。 

次はテキストボックスに文字列を書き込んで、作成（テキスト）ボタンを押してみましょう。 
[[画像:Outdata-PIONE-Basic9-2.png|border]] 
これによりAAA.txtがテキストの内容で作成されます。 

操作を終えるときには終了をクリックして下さい。終了通知が送られてインタラクティブ処理が完了します。 
また、htmlなどを実装する上で終了時には必ず終了通知finishを送信するように注意しましょう。 

=== 基本１０（ループ文） ===
　[[PIONE定義書]]にてループ文を作成してみましょう。 
Action内はシェルスクリプトですので、for文やwhile文を使用することで容易にループを実現できます。 
しかし、Actionに記述した処理は一つのルールに書かれるため、一かたまりの処理として一つのマシンで実行されてしまいます。 
それでは、処理を分割できる[[PIONE]]の長所を活かせていません。 
ループ内の一つひとつの処理を分割し、複数のマシンで短時間に処理を行うことを考えましょう。 

そこで、Flowでループ文に相当する内容を作成し、ループ内の個別の処理を各々のマシンに振り分ける工夫を施します。 

今回は、[[#基本７（制御文）]]での偶数奇数判定の処理を、最小値から最大値まで加算値を加算しながら行っていくプログラムを作成します。 
このプログラムは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic10 こちら]からダウンロードできます。 
最大値、最小値、加算値をパラメータで設定できるようにし、ルールLoopSystemにてループ文を実現しています。 

<pre>
param $maxval := 456
param $minval := 123
param $dval := 37

Rule Main
output '*.txt'
Flow
rule LoopSystem {val: $minval}
End

Rule LoopSystem
output '*.txt'
param $val
Flow
if $val <= $maxval
rule EvenOdd {val: $val}
end
if ($val + $dval) <= $maxval
rule LoopSystem {val: $val + $dval}
end
End

Rule EvenOdd
output '*.txt'
param $val
Flow
if $val % 2 == 0
rule Even {val: $val}
else
rule Odd {val: $val}
end
End

Rule Even
output '*.txt'
param $val
Action
echo "{$val} is even." >> Even{$val}.txt;
End

Rule Odd
output '*.txt'
Action
echo "{$val} is odd." >> Odd{$val}.txt;
End
</pre>

まず、MainルールからLoopSystemをval=最小値で呼び出し、その中でvalが最大値になるまでは加算値を加えながら再帰的にLoopSystemを呼び出しています。 
出力ファイル名を偶数のときはEven{$val}.txt、奇数のときはOdd{$val}.txtとしています。 

では、実行してみます。 

<pre>
/Basic10$ pione-client EvenOddLoop.pione
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{})
==> &Anonymous:Main([],{})
--> Rule Application: &Anonymous:Main([],{})
--> Distribution: &Anonymous:Main([],{})
>>> &Anonymous:LoopSystem([],{val:(123)})
==> &Anonymous:LoopSystem([],{val:(123)})
--> Rule Application: &Anonymous:LoopSystem([],{val:(123)})
--> Distribution: &Anonymous:LoopSystem([],{val:(123)})
>>> &Anonymous:EvenOdd([],{val:(123)})
>>> &Anonymous:LoopSystem([],{val:(160)})
==> &Anonymous:EvenOdd([],{val:(123)})
--> Rule Application: &Anonymous:EvenOdd([],{val:(123)})
--> Distribution: &Anonymous:EvenOdd([],{val:(123)})
>>> &Anonymous:Odd([],{val:(123)})
==> &Anonymous:LoopSystem([],{val:(160)})
--> Rule Application: &Anonymous:LoopSystem([],{val:(160)})
--> Distribution: &Anonymous:LoopSystem([],{val:(160)})
>>> &Anonymous:EvenOdd([],{val:(160)})
>>> &Anonymous:LoopSystem([],{val:(197)})
==> &Anonymous:Odd([],{val:(123)})
SH ------------------------------------------------------------
SH echo "123 is odd." >> Odd123.txt;
SH ------------------------------------------------------------
<== &Anonymous:Odd([],{val:(123)})

-中略-

==> &Anonymous:Even([],{val:(456)})
SH ------------------------------------------------------------
SH echo "456 is even." >> Even456.txt;
SH ------------------------------------------------------------
<== &Anonymous:Even([],{val:(456)})
<-- Distribution: &Anonymous:EvenOdd([],{val:(456)})
<-- Rule Application: &Anonymous:EvenOdd([],{val:(456)})
<== &Anonymous:EvenOdd([],{val:(456)})

-中略-

<-- Distribution: &Anonymous:LoopSystem([],{val:(160)})
<-- Rule Application: &Anonymous:LoopSystem([],{val:(160)})
<== &Anonymous:LoopSystem([],{val:(160)})
<-- Distribution: &Anonymous:LoopSystem([],{val:(123)})
<-- Rule Application: &Anonymous:LoopSystem([],{val:(123)})
<== &Anonymous:LoopSystem([],{val:(123)})
<-- Distribution: &Anonymous:Main([],{})
<-- Rule Application: &Anonymous:Main([],{})
<-- Distribution: &Anonymous:Root([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
<== &Anonymous:Main([],{})
</pre>

今回はパラメータをデフォルト値で実行しましたので、123から456まで37刻みで実行されます。lsコマンドで出力ファイルを確認します。 

<pre>
/Basic10$ ls process/output/
Even160.txt Even308.txt Even456.txt Odd197.txt Odd345.txt
Even234.txt Even382.txt Odd123.txt Odd271.txt Odd419.txt
</pre>

それぞれの値について偶数奇数の処理が実行されていることが確認できました。 

=== 基本１１（ループ文２） ===
　[[#基本１０（ループ文）]]でループの作成方法を示しました。 
しかし、[[#基本１０（ループ文）]]の書き方では逐次処理となってしまうので、ループ数に比例して処理時間が掛かってしまいます。 
この問題を解決する方法を考えましょう。 
以下に示すのは、val=0がmax=64になるまで1を足し続け、{$val}.txtを作成する、ループを使った処理の例です。 
以下に示していくファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic11 こちら]からダウンロードできます。 

<pre>
param $max := 64

Rule Main
output '*.txt'
Flow
rule LoopSystem {val: 0}
End

Rule LoopSystem
output '*.txt'
param $val
Flow
rule Test {val: $val}
if $val + 1 <= $max
rule LoopSystem {val: $val + 1}
end
End

Rule Test
output '{$val}.txt'
param $val
Action
touch {$O[1]}
End
</pre>

このままでは、[[#基本１０（ループ文）]]同様、ループ部分は、逐次処理になっています。 
そこで、ループの箇所を下記のような分割した形に書き換え、並列処理を試みます。 

<pre>
Rule LoopSystem
output '*.txt'
param $val
Flow
rule Test {val: $val}
if ($val * 2) + 1 <= $max
rule LoopSystem {val: ($val * 2) + 1}
end
if ($val * 2) + 2 <= $max
rule LoopSystem {val: ($val * 2) + 2}
end
End
</pre>

このようにすることでループに掛かる時間が改善されます。 
あるいはconstraintを使用して下記のように記述する方法もあります。 

<pre>
Rule LoopSystem
output '*.txt'
param $val
constraint $val <= $max
Flow
rule Test {val: $val}
rule LoopSystem {val: ($val * 2) + 1}
rule LoopSystem {val: ($val * 2) + 2}
End
</pre>

また、valの値を加算している箇所ですが、 

<pre>
rule LoopSystem {val: ($val * 2) + 1}
rule LoopSystem {val: ($val * 2) + 2}
</pre>

シーケンスを利用して下記のように書くこともできます。（参照：[[PIONEの式#シーケンス]]） 

<pre>
rule LoopSystem {val: ($val * 2) + (1|2)}
</pre>

問題：これを踏まえて[[#基本１０（ループ文）]]のループを改善してみましょう。 

解答例１ 
<pre>
Rule LoopSystem
output '*.txt'.all
param $val
Flow
if $val <= $maxval
rule EvenOdd {val: $val}
end
if (($val * 2) - $minval) + $dval <= $maxval
rule LoopSystem {val: (($val * 2) - $minval) + $dval}
end
if (($val * 2) - $minval) + ($dval * 2) <= $maxval
rule LoopSystem {val: (($val * 2) - $minval) + ($dval * 2)}
end
End
</pre>

Flow内の条件を分割しています。条件式が多少複雑になっていますので、演算の順番に注意しましょう。 
また、現在のバージョンでの四則演算は二項演算のみの対応となっていますので、三項以上の場合は必ず括弧で括るようにして下さい（参照：[[PIONEの式#四則演算における注意事項]]）。 

解答例２：constraintとシーケンスを利用した場合 
<pre>
Rule LoopSystem
output '*.txt'.all
param $val
constraint $val <= $maxval
Flow
rule EvenOdd {val: $val}
rule LoopSystem {val: (($val * 2) - $minval) + ($dval * (1|2))}
End
</pre>

これにより[[#基本１０（ループ文）]]よりも呼び出されるルールの階層は浅くなります。 
しかし、いずれも入れ子で呼び出されるのでルールが多くなるほど処理が重くなるでしょう。 
そこで１つのルールから一気にループ数だけのルールを呼び出す方法を考えます。この記述方法については[[#基本１５（ループ文３）]]をご覧下さい。 

=== 基本１２（チケット） ===
[[PIONE]]の目的の一つは、できる限り並列処理を行うことですので、必ずしも記述の順番通りにルールが実行される訳ではありません。 
ルールに順番を持たせたいときにはチケットという機能を利用します。但し、使い過ぎると待ち時間が多くなり並列計算できる[[PIONE]]の長所が活かせなくなってしまいますので注意が必要です。 
 

下記の内容をご覧下さい。(CreateList-instant.pione) 
このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic12 こちら]からダウンロードできます。 
<pre>
Rule Main
input '*.data'.all
output 'list.txt'
Flow
rule Touch0
rule CreateList
End

Rule Touch0
output '0.data'
Action
sleep 1
touch {$O[1]}
End

Rule CreateList
input '*.data'.all
output 'list.txt'
Action
ls *.data > {$O[1]}
End
</pre>
これはCreateListで.dataファイルの一覧をlist.txtに記述する処理ですが、途中のTouch0でも0.dataファイルを作成しています。 
この0.dataが一覧に含まれるかを検証してみましょう。 
 

入力ファイル用のディレクトリ(input)内
<pre>
/Basic12$ ls input/
1.data 2.data
</pre>
 

まずはMainルールを上記のようにそのまま記述している場合で実行してみます。 
<pre>
/Basic12$ pione-client CreateList-instant.pione -i input/
==> &Anonymous:Root([.DS_Store,1.data,2.data],{})
--> Rule Application: &Anonymous:Root([.DS_Store,1.data,2.data],{})
--> Distribution: &Anonymous:Root([.DS_Store,1.data,2.data],{})
>>> &Anonymous:Main([1.data,2.data],{})
==> &Anonymous:Main([1.data,2.data],{})
--> Rule Application: &Anonymous:Main([1.data,2.data],{})
--> Distribution: &Anonymous:Main([1.data,2.data],{})
>>> &Anonymous:Touch0([],{})
>>> &Anonymous:CreateList([1.data,2.data],{})
==> &Anonymous:Touch0([],{})
SH ------------------------------------------------------------
SH sleep 1
SH touch 0.data
SH ------------------------------------------------------------
<== &Anonymous:Touch0([],{})
==> &Anonymous:CreateList([1.data,2.data],{})
SH ------------------------------------------------------------
SH ls *.data > list.txt
SH ------------------------------------------------------------
<== &Anonymous:CreateList([1.data,2.data],{})
<-- Distribution: &Anonymous:Main([1.data,2.data],{})
<-- Rule Application: &Anonymous:Main([1.data,2.data],{})
<-- Distribution: &Anonymous:Root([.DS_Store,1.data,2.data],{})
<== &Anonymous:Main([1.data,2.data],{})
<-- Rule Application: &Anonymous:Root([.DS_Store,1.data,2.data],{})
<== &Anonymous:Root([.DS_Store,1.data,2.data],{})
</pre>
 

では出力ファイルlist.txtを確認してみます。 
<pre>
/Basic12$ cat process/output/list.txt
1.data
2.data
</pre>
0.dataが含まれませんでした。 
これはTouch0とCreateListが同時に動き、Touch0が完了する前にCreateListが実行されているため、作成された0.dataがCreateListの入力ファイルとして登録されなかったからです。 
 

では、チケットの機能を使ってMainルールを下記のようにしてみます。 
<pre>
Rule Main
input '*.data'.all
output 'list.txt'
Flow
rule Touch0 ==> <T>
rule <T> ==> CreateList
End
</pre>
上記のようにチケット名は<>で囲んで、ルールとチケット間を==>で繋いで使用します。 

 

チケット名を省略したい場合は下記のように記述します。 
<pre>
rule Touch0 >>> CreateList
</pre>
 

下記のように連続させることも可能です。 
<pre>
rule First >>> Second >>> Third
</pre>
 

また複数チケットの発行もできます。 
<pre>
rule Touch0 ==> (<T1>|<T2>)
rule <T1> ==> CreateList
rule <T2> ==> CreateList2
</pre>
 

逆に複数チケットからのルール実行も可能です。 
<pre>
rule Touch0 ==> <T0>
rule Touch1 ==> <T1>
rule (<T0>|<T1>) ==> CreateList
</pre>
上記の場合はチケットT0かつT1が発行されてからCreateListが実行されます。 
 

では、実行してみます。 
<pre>
/Basic12$ pione-client CreateList-ticket.pione -i input/
==> &Anonymous:Root([.DS_Store,1.data,2.data],{})
--> Rule Application: &Anonymous:Root([.DS_Store,1.data,2.data],{})
--> Distribution: &Anonymous:Root([.DS_Store,1.data,2.data],{})
>>> &Anonymous:Main([1.data,2.data],{})
==> &Anonymous:Main([1.data,2.data],{})
--> Rule Application: &Anonymous:Main([1.data,2.data],{})
--> Distribution: &Anonymous:Main([1.data,2.data],{})
>>> &Anonymous:Touch0([],{})
==> &Anonymous:Touch0([],{})
SH ------------------------------------------------------------
SH sleep 1
SH touch 0.data
SH ------------------------------------------------------------
<== &Anonymous:Touch0([],{})
<-- Distribution: &Anonymous:Main([1.data,2.data],{})
--> Distribution: &Anonymous:Main([1.data,2.data],{})
>>> &Anonymous:CreateList([1.data,2.data,0.data],{})
==> &Anonymous:CreateList([1.data,2.data,0.data],{})
SH ------------------------------------------------------------
SH ls *.data > list.txt
SH ------------------------------------------------------------
<== &Anonymous:CreateList([1.data,2.data,0.data],{})
<-- Distribution: &Anonymous:Main([1.data,2.data],{})
<-- Rule Application: &Anonymous:Main([1.data,2.data],{})
<-- Distribution: &Anonymous:Root([.DS_Store,1.data,2.data],{})
<== &Anonymous:Main([1.data,2.data],{})
<-- Rule Application: &Anonymous:Root([.DS_Store,1.data,2.data],{})
<== &Anonymous:Root([.DS_Store,1.data,2.data],{})
/Basic12$ cat process/output/list.txt
0.data
1.data
2.data
</pre>
今度は0.dataが含まれるようになりました。 
 

=== 基本１３（orの使用例） ===
inputやoutputで宣言するときにorや|で繋ぐと、指定した複数種類のファイルからいずれかを入力や出力に使用することができます。 
以下で使用するファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic13 こちら]からダウンロードできます。 
 

==== 入力ファイルでの使用例 ====
<pre>
Rule Main
input '1.txt' or '2.txt' or '3.txt'
output 'out.txt'
Action
cp {$I[1]} {$O[1]}
End
</pre>
上記では入力ファイルに1.txt, 2.txt, 3.txtのいずれかがあればout.txtにコピーする処理となっています。 
 

例えば2.txtだけあった場合でも実行されます。 
<pre>
/Basic13$ pione-client test.pione -i ./input/
==> &Anonymous:Root([.DS_Store,2.txt],{})
--> Rule Application: &Anonymous:Root([.DS_Store,2.txt],{})
--> Distribution: &Anonymous:Root([.DS_Store,2.txt],{})
>>> &Anonymous:Main([2.txt],{})
==> &Anonymous:Main([2.txt],{})
SH ------------------------------------------------------------
SH cp 2.txt out.txt
SH ------------------------------------------------------------
<== &Anonymous:Main([2.txt],{})
<-- Distribution: &Anonymous:Root([.DS_Store,2.txt],{})
<-- Rule Application: &Anonymous:Root([.DS_Store,2.txt],{})
<== &Anonymous:Root([.DS_Store,2.txt],{})
</pre>
上記の使用例は入力ファイルが１つだけあった場合のみに対応しています。 
複数のファイルがあった場合、複数ファイルで上書きコピーされてしまいます。 
 

==== 出力ファイルでの使用例 ====
<pre>
param $Mode := 1

Rule Main
output 'out1.txt' or 'out2.txt' or 'err.txt'
Action
if [ {$Mode} -eq 1 ] ; then
echo "Mode: {$Mode}" > {$O[1].nth(1)}
elif [ {$Mode} -eq 2 ] ;then
echo "Mode: {$Mode}" > {$O[1].nth(2)}
else
echo "Error: Mode {$Mode} is not Supported!" > {$O[1].nth(3)}
fi
End
</pre>
これはパラメータModeが1のときはout1.txtを作成し、2のときはout2.txtを作成し、それ以外についてはエラーを残す処理となっています。 
out1.txt, out2.txt, err.txtのいずれかが出力されることで処理が完了しますので、状況に応じて作成するファイルを変えたいときに有効です。 
.nth()は引数で指定した要素を取り出すシーケンスのメソッドです。（参照：[[PIONEの式#シーケンス]]） 
 

デフォルト（Mode=1）で実行してみます。 
<pre>
/Basic13$ pione-client OutputOr.pione
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{})
==> &Anonymous:Main([],{})
SH ------------------------------------------------------------
SH if [ 1 -eq 1 ] ; then
SH echo "Mode: 1" > out1.txt
SH elif [ 1 -eq 2 ] ;then
SH echo "Mode: 1" > out2.txt
SH else
SH echo "Error: Mode 1 is not Supported!" > err.txt
SH fi
SH ------------------------------------------------------------
<-- Distribution: &Anonymous:Root([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
<== &Anonymous:Main([],{})
/Basic13$ cat process/output/out1.txt
Mode: 1
</pre>
out1.txtが作成されて完了します。 
 

Mode=0で実行してみます。 
<pre>
/Basic13$ pione-client OutputOr.pione --params={Mode:0}
"{Mode:0}"
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{})
==> &Anonymous:Main([],{})
SH ------------------------------------------------------------
SH if [ 0 -eq 1 ] ; then
SH echo "Mode: 0" > out1.txt
SH elif [ 0 -eq 2 ] ;then
SH echo "Mode: 0" > out2.txt
SH else
SH echo "Error: Mode 0 is not Supported!" > err.txt
SH fi
SH ------------------------------------------------------------
<-- Distribution: &Anonymous:Root([],{})
<== &Anonymous:Main([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
/Basic13$ cat process/output/err.txt
Error: Mode 0 is not Supported!
</pre>
err.txtが作成されて完了します。 

=== 基本１４（例外） ===
[[PIONE]]でも入出力ファイルにワイルドカード*を使用して全ての該当ファイルを対象とできますが、exceptを使用することにより対象外とするファイルを指定できます。メソッドexcept, exceptionsについては[[PIONEの式#データ表現型]]を参照して下さい。 
 

<pre>
Rule Main
input 'AllData.txt'
output '*.txt'.all.except($I[1])
Flow
rule GetLine {filename:"Data1", line:1}
rule GetLine {filename:"Data2", line:2}
rule GetLine {filename:"Data3", line:3}
End

Rule GetLine
input 'AllData.txt'
output '{$filename}.txt'
param $filename
param $line
Action
head -{$line} {$I[1]} | tail -1 > {$O[1]}
End
</pre>
上記はAllData.txtから1, 2, 3行目を指定した.txtファイルに出力する処理です。出力ファイルは全ての.txtとしていますが、exceptによってAllData.txtを対象外としています。対象外としていない場合はAllData.txtが出力ファイルの条件を満たしていますので、発火しません。 
このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic14 こちら]からダウンロードできます。
 

AllData.txtを下記の内容として実行してみます。 
<pre>
ABC
DEF
GHI

</pre>
 

実行結果 
<pre>
/Basic14$ pione-client DivideText.pione -i DivideTextInput/
==> &Anonymous:Root([.DS_Store,AllData.txt],{})
--> Rule Application: &Anonymous:Root([.DS_Store,AllData.txt],{})
--> Distribution: &Anonymous:Root([.DS_Store,AllData.txt],{})
>>> &Anonymous:Main([AllData.txt],{})
==> &Anonymous:Main([AllData.txt],{})
--> Rule Application: &Anonymous:Main([AllData.txt],{})
--> Distribution: &Anonymous:Main([AllData.txt],{})
>>> &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data1"),line:(1)})
>>> &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data2"),line:(2)})
==> &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data1"),line:(1)})
SH ------------------------------------------------------------
SH head -1 AllData.txt | tail -1 > Data1.txt
SH ------------------------------------------------------------
>>> &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data3"),line:(3)})
<== &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data1"),line:(1)})
==> &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data2"),line:(2)})
SH ------------------------------------------------------------
SH head -2 AllData.txt | tail -1 > Data2.txt
SH ------------------------------------------------------------
<== &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data2"),line:(2)})
==> &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data3"),line:(3)})
SH ------------------------------------------------------------
SH head -3 AllData.txt | tail -1 > Data3.txt
SH ------------------------------------------------------------
<== &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data3"),line:(3)})
<-- Distribution: &Anonymous:Main([AllData.txt],{})
<-- Rule Application: &Anonymous:Main([AllData.txt],{})
<-- Distribution: &Anonymous:Root([.DS_Store,AllData.txt],{})
<== &Anonymous:Main([AllData.txt],{})
<-- Rule Application: &Anonymous:Root([.DS_Store,AllData.txt],{})
<== &Anonymous:Root([.DS_Store,AllData.txt],{})
/Basic14$ cat process/output/Data1.txt
ABC
/Basic14$ cat process/output/Data2.txt
DEF
/Basic14$ cat process/output/Data3.txt
GHI
</pre>
1, 2, 3行目の内容がそれぞれのファイルに出力されました。 
 

.except($I[1])を除いた場合は発火しません。 
<pre>
/Basic14$ pione-client DivideText.pione -i DivideTextInput/
==> &Anonymous:Root([.DS_Store,AllData.txt],{})
--> Rule Application: &Anonymous:Root([.DS_Store,AllData.txt],{})
<-- Rule Application: &Anonymous:Root([.DS_Store,AllData.txt],{})
<== &Anonymous:Root([.DS_Store,AllData.txt],{})
</pre>
 

また、exceptionsを使用すると設定している例外をリストで得ることができます。 
<pre>
Rule Main
input '1.txt'
input '2.txt'
input '3.txt'
output '*.txt'.all.except($I[1] or $I[2] or $I[3])
Action
for data in {$O[1].exceptions()}
do
cat $data >> AllData.txt
wc $data >> AllInfo.txt
done
End
</pre>
上記の例ではoutputに例外が$I[1] or $I[2] or $I[3]と設定されているので、{$O[1].exceptions()}では1.txt 2.txt 3.txtのリストとして得られるので、for文がこれらのファイルによって回ることになります。 
 

=== 基本１５（ループ文３） ===
[[#基本１０（ループ文）]]、[[#基本１１（ループ文２）]]にてループ文を記述する方法を示しました。しかし、いずれも多くのルールを入れ子で呼ぶことになり、ループ数が多くなると入出力ファイルの引き継ぎも多くなり時間が掛かってしまいます。今回は一つのルールから全てのルールを呼び出すようにしてループを行うようにしてみます。 
 

下記の整数型メソッドuptoを使用すると、１つのルールからパラメータを一気に設定して各々の値でルールを実行することができます。uptoは引数の値まで１ずつ加算しながら整数を返すメソッドです。（参照：[[PIONEの式#整数型(integer)]]）
<pre>
param $min := 0
param $max := 64

Rule Main
output '*.txt'
Flow
rule Test {val: $min.upto($max)}
End

Rule Test
output '{$val}.txt'
param $val
Action
touch {$O[1]}
End
</pre>
 

またdowntoを使用する方法もあります。uptoは引数の値まで１ずつ減算しながら整数を返すメソッドです。（参照：[[PIONEの式#整数型(integer)]]） 
<pre>
rule Test {val: $max.downto($min)}
</pre>
 

uptoを利用すると、[[#基本１０（ループ文）]]は下記のようになります。 
<pre>
param $maxval := 456
param $minval := 123
param $dval := 37

Rule Main
output '*.txt'.all
Flow
rule EvenOdd {val: $minval + ($dval * (0.upto(($maxval - $minval)/$dval)))}
End

Rule EvenOdd
output '*.txt'
param $val
Flow
if $val % 2 == 0
rule Even {val: $val}
else
rule Odd {val: $val}
end
End

Rule Even
output '*.txt'
param $val
Action
echo "{$val} is even." >> Even{$val}.txt;
End

Rule Odd
output '*.txt'
Action
echo "{$val} is odd." >> Odd{$val}.txt;
End
</pre>このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic15 こちら]からダウンロードできます。
 

valに設定する式が複雑な場合は下記のように一旦、[[変数束縛]]で計算したものを利用する方法もあります。 
<pre>
param $maxval := 456
param $minval := 123
param $dval := 37
$loop := ($maxval - $minval)/$dval

Rule Main
output '*.txt'.all
Flow
rule EvenOdd {val: $minval + ($dval * (0.upto($loop))}
End

-以下略-
</pre>
上記の場合は変数loopにパラメータから計算したループ数を設定しています。 
 

=== 基本１６（ランダム） ===
メソッドrandomを使用するとランダムに選んだファイルを出力することができます。（現v0.5.0では未実装） 
 

<pre>
Rule Main
input '*.txt'
output '*.out'.all.random
Action
max=$(wc -l {$I[1]} | awk '{print $1}')
for (( i=1; i<${max}; i++ ))
do
head -${i} {$I[1]} | tail -1 > {$I[1][1]}-{$i}.out
done
End
</pre>
上記の例では入力.txtファイルからランダムに選んだ行数を.outファイルとして出力します。このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic16 こちら]からダウンロードできます。 
 

== 応用 ==
さて、ここまでの基本を組み合わせて、[[Eosのコマンド]]を使用する問題を考えてみましょう。 
 

=== 応用１（フローの制御）===
==== 問題１ ====
<div>*.mrc（[[mrcImage]]）と*.prametersで指定される入力ファイルがあります。</div>
<div>それぞれの*.mrcファイルから最大値を中心として切り出した*.roiを出力するCenterGet.pioneを考えてみましょう。 
但し、*.parametersは以下のフォーマットで切り出しサイズ(Sx, Sy, Sz)を格納しているファイルとします。</div>
 

<div>*.parametersのフォーマット</div>
<pre>
Sx Sy Sz
</pre>
 

-----

　応用問題１：上記のCenterGet.pioneを作成してみましょう。

-----
 

==== 解答例 ====
<pre>
Rule Main
input '*.mrc'.all
output '*.roi'
Flow
rule First
rule Second
End

Rule First
input '*.mrc'
output '{$I[1]}.info'
Action
mrcImageInfo -I -i {$I[1]} \
| head -2 | tail -1 \
| awk '{printf("%s %s %s", $3, $4, $5)}' \
| tr -c '[0-9]' ' ' \
> {$O[1]}
End

Rule Second
input '*.mrc'
input '{$I[1]}.info'
input '{$I[1][1]}.parameters'
output '{$I[1][1]}.roi'
Action
Center_x=$(awk '{printf("%s\n", $1)}' {$I[2]})
Center_y=$(awk '{printf("%s\n", $2)}' {$I[2]})
Center_z=$(awk '{printf("%s\n", $3)}' {$I[2]})
N_x=$(awk '{printf("%s\n", $1)}' {$I[3]})
N_y=$(awk '{printf("%s\n", $2)}' {$I[3]})
N_z=$(awk '{printf("%s\n", $3)}' {$I[3]})
mrcImageCenterGet -i {$I[1]} -o {$O[1]} \
-Cx $Center_x -Cy $Center_y -Cz $Center_z \
-Nx $N_x -Ny $N_y -Nz $N_z
End
</pre>
このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Advanced1 こちら]からダウンロードできます。 
 
主に[[mrcImageCenterGet]]を用いて切り出しを行っています。 
<pre>
Main: .mrcファイルについてFirst, Secondの処理を行います。
First: .mrcファイルの最大値の座標を得て、.mrc.infoファイルに格納します。
Second: .mrcから.mrc.infoの座標を中心に.parametersのサイズで切り出しを行います。
</pre>
 

==== 実行結果 ====
入力ファイル 
[[:Media:1VOM.mrc|mrcファイル1]]
<table>
<tr>
<td>[[画像:Input-1VOM.png]] 
xy平面 
</td>
<td>[[画像:Input1-1VOM.png]] 
yz平面 
</td>
</tr>
</table>
<pre>
Min: 0 (0, 0, 0)
Max: 3398.12 (23, 55, 41)
Mean: 72.129
SD: 294.805
SE: 0.368507
Sum: 4.61626e+07
</pre>
最大値の座標: (23, 55, 41) 
 

[[:Media:Input-1VOM-N.mrc|mrcファイル2]]
<table>
<tr>
<td>[[画像:Input-1VOM-N.png]] 
xy平面 
</td>
<td>[[画像:Input1-1VOM-N.png]] 
yz平面 
</td>
</tr>
</table>
<pre>
Min: -2390.42 (77, 14, 69)
Max: 4374.62 (17, 62, 46)
Mean: 72.1487
SD: 577.82
SE: 0.722275
Sum: 4.61752e+07
</pre>
最大値の座標: (17, 62, 46) 
 

parametersファイル1, 2の両方を下記に設定して実行してみます。 
<pre>
40 40 50
</pre>
 

コマンド 
<pre>
pione-client CenterGet.pione -i CenterGetInput/ -b CenterGet
</pre>
 

実行結果 
1VOM.roi, 1VOM-N.roiのファイルが出力されます。 
 
[[mrcImageInfo]]を使って、最大値の座標が中心になっているか確認してみます。 
<pre>
/Advanced1$ mrcImageInfo -I -i CenterGet/output/1VOM.roi
Min: 0 (0, 0, 0)
Max: 3398.12 (19, 19, 24)
Mean: 241.805
SD: 500.988
SE: 1.77126
Sum: 1.93444e+07
/Advanced1$ mrcImageInfo -I -i CenterGet/output/1VOM-N.roi
Min: -1893.8 (0, 4, 33)
Max: 4374.62 (19, 19, 24)
Mean: 157.55
SD: 648.124
SE: 2.29147
Sum: 1.2604e+07
</pre>
最大値を中心に切り出していることが分かります。 
 

==== 補足(ファイルの確認用コマンド) ====
出力したファイルと入力ファイルの違いを見るために後処理を追加します。 
 
作成例 
<pre>
Rule Main
input '*.mrc'.all
output '*.roi'
output '*.tiff'
Flow
rule First
rule Second
rule Final
End

-中略-

Rule Final
input '*.mrc'
input '{$I[1][1]}.roi'
output '{$I[1]}-1.tiff'
output '{$I[2]}-1.tiff'
output '{$I[1]}-2.tiff'
output '{$I[2]}-2.tiff'
Action
mrcImageProjection -i {$I[1]} -o {$I[1]}.2d
mrc2tiff -i {$I[1]}.2d -o {$O[1]}
mrcImageProjection -i {$I[1]} -o {$I[1]}.2d1 -m 1
mrc2tiff -i {$I[1]}.2d1 -o {$O[3]}
mrcImageProjection -i {$I[2]} -o {$I[2]}.2d
mrc2tiff -i {$I[2]}.2d -o {$O[2]}
mrcImageProjection -i {$I[2]} -o {$I[2]}.2d1 -m 1
mrc2tiff -i {$I[2]}.2d1 -o {$O[4]}
End
</pre>
これにより入力ファイル(mrc), 出力ファイル(roi)についてxy平面とyz平面へ投影した画像をtiffファイルで出力します。 
 

出力ファイル 
roiファイル1 
<table>
<tr>
<td>[[画像:Outdata-PIONE-Advanced1-1.png]] 
xy平面 
</td>
<td>[[画像:Outdata1-PIONE-Advanced1-1.png]] 
yz平面 
</td>
</tr>
</table>
 

roiファイル2 
<table>
<tr>
<td>[[画像:Outdata-PIONE-Advanced1-2.png]] 
xy平面 
</td>
<td>[[画像:Outdata1-PIONE-Advanced1-2.png]] 
yz平面 
</td>
</tr>
</table>
 

後処理をしたくないときはMainのoutputとFlow内をコメントアウトするだけです。 
<pre>
Rule Main
input '*.mrc'.all
output '*.roi'
# output '*.tiff'
Flow
rule Initial
rule First
rule Second
# rule Final
End

-後略-

</pre>
 

==== 補足(デフォルトサイズの設定) ====
.parametersなどのファイルがない場合にパラメータ入力で設定したい場合の前処理を追加します。 
 
作成例 
<pre>
Basic Param
$Nx := 40
$Ny := 40
$Nz := 50
End

Rule Main
input '*.mrc'.all
input '*.parameters'
output '*.roi'
output '*.tiff'
Flow
rule Initial
rule First
rule Second
rule Final
End

Rule Initial
input '*.mrc'
output '{$I[1][1]}.parameters'
Action
echo "{$Nx} {$Ny} {$Nz}" > {$O[1]}
End

-後略-

</pre>
このようにすると、.parametersがない場合にはオプション--paramsまたはデフォルト値(40, 40, 50)によってサイズを設定することができます。但し、入力ファイルに.parametersが１つもない場合は動きません。その場合はtouchなどを使用して.parameterを１つは用意する必要があります。 
 

1VOM.parametersのみ下記のように設定してみます。 
<pre>
64 64 64
</pre>
 

Nx=80のみをパラメータとしてコマンド入力してみます。 
<pre>
/Advanced1$ pione-client CenterGet.pione -i ${EOS_HOME}/tutorial/SampleData/ -b CenterGet --params="{Nx:80}"
</pre>

出力ファイル 
1VOM.roiはファイルに従ったサイズになっています。 
<table>
<tr>
<td>[[画像:Outdata-PIONE-Advanced1-3.png]] 
xy平面 
</td>
<td>[[画像:Outdata1-PIONE-Advanced1-3.png]] 
yz平面 
</td>
</tr>
</table>
 

1VOM-N.roiはNxがコマンドの引数、Ny, Nzはデフォルト値のパラメータによるサイズになります。 
<table>
<tr>
<td>[[画像:Outdata-PIONE-Advanced1-4.png]] 
xy平面 
</td>
<td>[[画像:Outdata1-PIONE-Advanced1-4.png]] 
yz平面 
</td>
</tr>
</table>
 

=== 応用２（ウェブページでパラメータを設定しながらコマンドを実行）===
　次は[[#基本８（インタラクティブ操作）]]のようにウェブページの操作を行い、[[Eosのコマンド]]を実行する処理を作ってみましょう。 
 

==== 問題２ ====
2Dファイル([[mrcImage]])を入力ファイルとし、ローパスフィルタ([[mrcImageLowPassFilter]])をウェブページの操作によって実行する次のコマンドを考えます。
*入力ファイルはファイル選択画面から自由に選べるようにし、オプションの値も画面操作で設定できるようにします。
*コマンド実行後は入力ファイルと出力ファイルの画像ファイルをそれぞれ表示して比較できるようにします。
*この画面を見ながら再設定するか、終了するかを選び、終了後に最後の変換ファイルを出力ファイルとして得られるようにします。 
 

-----

　応用問題２：上記の機能を持つパッケージLowPassFilter.ppgを作成してみましょう。

-----
 

==== 解答例 ====
[[PIONE定義書]]、[[html]]ファイル、[[cgi]]ファイルをそれぞれ作成します。 
 

===== [[PIONE定義書]] =====
メイン(Main.pione)の処理を定義します。今回は設定のほとんどをウェブページに委ねるのでここでは出力ファイル名のみ定義しています。 
<pre>
Rule Main
output '*.lpf'.all
Flow
rule Interaction
End

</pre>
 

インタラクティブ(Interaction.pione)の処理を定義します。このファイルは再利用できるように拡張子が付いた全てのファイルを呼び出し元に出力できるようにしています。 
<pre>
Rule Interaction
output '*.*'.all
Action
# build public directory for pione-interactive
mkdir public
cp etc/* public
cp bin/* public

# start interactive operation
pione-interactive browser --public public

cp public/* .
End

</pre>
 
パッケージ用のアノテーション(Annotation.pione)を定義します。 
<pre>
.@ PackageName :: "LowPassFilter"
.@ Editor :: "Kinoshita"
.@ Tag :: "v0.1.0"

</pre>
 

===== [[html]]ファイル =====
Index.htmlはコマンド選択画面にしています。ここから実行したいコマンドを選択します。 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>InteractiveCommand Index Page</title>
</head>
<body>
<a href="mrcImageLowPassFilter.html">mrcImageLowPassFilter</a>
 
 
<a href="?pione-action=finish">終了</a>
</body>
</html>
</pre>
 

mrcImageLowPassFilter.htmlでコマンドや入力ファイルなどのオプションを設定できるようにします。開始ボタンでmrcImageLowPassFilterが実行されます。 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>mrcImageLowPassFilter</title>
</head>
<body>
<form action="mrcImageLowPassFilter.cgi" method="post" enctype="multipart/form-data">
<button type="submit">開始</button>
 
<table>
<tr>
<td>
<input type="file" name="InputFile"/>
</td>
<td>
入力ファイル名(-i)
</td>
</tr>
<tr>
<td>
<input type="text" name="OutputFile" value="outdata.lpf"/>
</td>
<td>
出力ファイル名(-o)
</td>
</tr>
<tr>
<td>
<input type="text" name="HalfValuePoint" value="1.0"/>
</td>
<td>
HalfValuePoint[A-1] (強度を半分に落とす空間周波数を示す)(-hvp)
</td>
</tr>
<tr>
<td>
<input type="text" name="Width" value="1.0"/>
</td>
<td>
空間周波数のcos関数の幅を設定(-w)
</td>
</tr>
<tr>
<td>
<select name="Mode">
<option value="1">1: ステップフィルタ</option>
<option value="2">2: cosフィルタ</option>
<option value="3">3: expフィルタ</option>
<option value="4">4: ガウシアンフィルタ</option>
<option value="5">5: ローレンツ型フィルタ</option>
</select>
</td>
<td>
モード(-m)
</td>
</tr>
</table>
</form>
 
 
<a href="?pione-action=finish">終了</a>
</body>
</html>
</pre>
 

===== [[cgi]]ファイル =====
mrcImageLowPassFilter.cgi 
<pre>
#!/usr/bin/env ruby

require 'cgi'

cgi = CGI.new

### Header
HTMLstr = ""
HTMLstr += "<!DOCTYPE html>"
HTMLstr += "<html>"
HTMLstr += "<head>"
HTMLstr += "<title>mrcImageLowPassFilter</title>"
HTMLstr += "</head>"

HTMLstr += "<body>"

### Close or Back
HTMLstr += '<a href="?pione-action=finish">Close</a>'
HTMLstr += " "
HTMLstr += '<a href="mrcImageLowPassFilter.html">Back</a>'
HTMLstr += " "
HTMLstr += " "

# Main Process

## Query to Parameters

### Copy InputFile
fpQueryInputFile = cgi.params['InputFile'][0]
strInputFile = fpQueryInputFile.original_filename
fpInputFile = open(strInputFile, "wb")
fpInputFile.write(fpQueryInputFile.read)
fpInputFile.close

### Other Query
strOutputFile = cgi['OutputFile']
strHalfValuePoint = cgi['HalfValuePoint']
strWecth = cgi['Width']
strMode = cgi['Mode']

### mrcImageLowPassFilter
command = "mrcImageLowPassFilter"
command += ' -i "' + strInputFile + '"'
command += ' -o "' + strOutputFile + '"'
command += ' -hvp "' + strHalfValuePoint + '"'
command += ' -w "' + strWecth + '"'
command += ' -m "' + strMode + '"'
system(command)

### mrc2gif
#### For input
strGifInputFile = strInputFile + ".gif"
command = "mrc2gif"
command += ' -i "' + strInputFile + '"'
command += ' -o "' + strGifInputFile + '"'
system(command)

#### For output
strGifOutputFile = strOutputFile + ".gif"
command = "mrc2gif"
command += ' -i "' + strOutputFile + '"'
command += ' -o "' + strGifOutputFile + '"'
system(command)

### mrcImageInfo
#### For input
strInfoInputFile = strInputFile + ".info"
command = "mrcImageInfo"
command += ' -I'
command += ' -i "' + strInputFile + '"'
command += ' -o "' + strInfoInputFile + '"'
system(command)

#### For output
strInfoOutputFile = strOutputFile + ".info"
command = "mrcImageInfo"
command += ' -I'
command += ' -i "' + strOutputFile + '"'
command += ' -o "' + strInfoOutputFile + '"'
system(command)

## View as HTML Statement

### Table
HTMLstr += "<table>"

#### Title
HTMLstr += "<tr>"
HTMLstr += "<td>" + strInputFile + "</td>"
HTMLstr += "<td>" + strOutputFile + "</td>"
HTMLstr += "</tr>"

#### GifImage
##### For Input
HTMLstr += "<tr>"
HTMLstr += "<td>"
HTMLstr += '<img src="' + strGifInputFile + '">'
HTMLstr += "</td>"
##### For Output
HTMLstr += "<td>"
HTMLstr += '<img src="' + strGifOutputFile + '">'
HTMLstr += "</td>"
HTMLstr += "</tr>"

#### mrcImageInfo
##### For Input
HTMLstr += "<tr>"
HTMLstr += "<td>"
fpInfoInputFile = open(strInfoInputFile, "r")
fpInfoInputFile.each do |line|
HTMLstr += line + " "
end
fpInfoInputFile.close
HTMLstr += "</td>"
##### For Output
HTMLstr += "<td>"
fpInfoOutputFile = open(strInfoOutputFile, "r")
fpInfoOutputFile.each do |line|
HTMLstr += line + " "
end
fpInfoOutputFile.close
HTMLstr += "</td>"
HTMLstr += "</tr>"

HTMLstr += "</table>"

HTMLstr += "</body>"
HTMLstr += "</html>"

# Output as html
cgi.out(type: "text/html") do
HTMLstr
end

</pre>
htmlヘッダなどの書き込み、クエリを変数やファイルに変換、[[Eosのコマンド]]実行、実行結果をhtml化の順に記述しています。このコードでは[[mrcImageLowPassFilter]]の結果を[[gif]]画像と[[mrcImageInfo]](-I)の情報を表示して比較できるようにしています。 
 

これらのファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Advanced2 こちら]からダウンロードできます。 
 

==== [[パッケージ作成]] ====
コードが完成したら[[パッケージ作成]]を行います。 
<pre>
/PIONE$ pione package build Advanced2
info: update the package info file: local:/Eos/tutorial/SampleCode/PIONE/Advanced2/pione-package.json
info: Package local:/Eos/tutorial/SampleCode/PIONE/LowPassFilter(Kinoshita)+v0.1.0.ppg has been built successfully.
</pre>
 

==== 実行結果 ====
では、動作させてみましょう。 
[[PIONE Webclient]]のジョブページで実行し、Interactionを選択してindexページを開きます。ここでmrcImageLowPassFilterを選択すると設定画面が表示されます。ここでは入力ファイルや設定を変更しながらコマンドの実行を試すことができます。終了やCloseを選択すると、最後に処理を行った結果で出力ファイルが残ります。また、出力ファイル名を変更すると複数のファイルを残すことができます。 
 

[[Media:Input-1VOM-N-2D.mrc|入力ファイル]](2D) 
<table>
<tr>
<td>[[画像:Input-1VOM-N-2D.png]]</td>
<td>最小 
最大 
平均値 
標準偏差 
標準誤差 
</td>
<td>-18651.7 (10, 1, 0) 
52942.7 (24, 39, 0) 
7214.87 
10067.6 
125.845 
</td>
</tr>
</table>
 

<table>
<tr>
<td>実行例1</td>
</tr>
<tr>
<td>[[画像:Outdata-PIONE-Advanced2-1.png|border]]</td>
<td>></td>
<td>[[画像:Outdata1-PIONE-Advanced2-1.png|border]]</td>
</tr>
<tr>
<td>実行例2</td>
</tr>
<tr>
<td>[[画像:Outdata-PIONE-Advanced2-2.png|border]]</td>
<td>></td>
<td>[[画像:Outdata1-PIONE-Advanced2-2.png|border]]</td>
</tr>
<tr>
<td>実行例3</td>
</tr>
<tr>
<td>[[画像:Outdata-PIONE-Advanced2-3.png|border]]</td>
<td>></td>
<td>[[画像:Outdata1-PIONE-Advanced2-3.png|border]]</td>
</tr>
</table>
 

終了後にResult Filesからファイルをダウンロードすると、outputディレクトリにて最後に変換した.lpfファイルを得ることができます。あるいはこの[[PIONE定義書]]に処理を追加して、作成した.lpfファイルを入力ファイルとして使用することもできます。 
 

==== 補足（不要ファイルの削除） ====
今回の処理は操作によって自由にファイルが作成できます。しかし、中には不要なファイルも出てくる場合もあります。そこで、補足処理としてサーバ上のファイルリストを表示し、不要ファイルを削除できるようにしてみましょう。新しく下記のファイルを追加します。なお、pione-action=...については[[インタラクションAPI]]に詳細を記載しています。 
 

/etc/FileDelete.html 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>InteractiveCommand Index Page</title>
</head>
<body>
<a href="index.html">戻る</a> 
<a href="?pione-action=finish">終了</a> 
 
<form action="FileDelete.cgi" method="post" enctype="multipart/form-data">
削除ファイル名 
<input type="text" name="DeleteFile" value=""/>
<button type="submit">削除</button>
</form>
ファイルリスト 
<script src="http://code.jquery.com/jquery-1.11.1.min.js"></script>
<div id="textDiv"></div>
<script type="text/javascript">
var div = document.getElementById("textDiv");
div.textContent = "";
$.getJSON("./", {"pione-action": "list"}, function(data){
$.each(data, function() {
strOut = ".lpf"
if( this.name.indexOf(strOut) + strOut.length == this.name.length ){
div.textContent += this.name +"\n";
}
});
});
</script>
</body>
</html>
</pre>
ファイルリストではpione-action=listによって得たファイルリストの中から最後が.lpfで終わるファイルのみを出力するようにしています。このリストを見ながら削除するファイルをテキストボックスに書き込んで、削除ボタンを押すと削除処理(FileDelete.cgi)が行われます。 
 

/bin/FileDelete.cgi 
<pre>
#!/usr/bin/env ruby

require 'cgi'

cgi = CGI.new

### Header
HTMLstr = ""
HTMLstr += "<!DOCTYPE html>"
HTMLstr += "<html>"
HTMLstr += "<head>"
HTMLstr += "<title>FileDelete</title>"

## Query to Parameters
strDeleteFile = cgi['DeleteFile']

## View as HTML Statement
HTMLstr += '<meta http-equiv="refresh" content="0;URL=./' + strDeleteFile + '?pione-action=delete">'

HTMLstr += "</head>"
HTMLstr += "</html>"

# Output as html
cgi.out(type: "text/html") do
HTMLstr
end
</pre>
ヘッダにてDeleteFileを削除する操作(pione-action=delete)を行っています。 
 

さらに出来上がったページへアクセスするためにindex.htmlのbody内に下記の内容を追加します。 
<pre>
<a href="FileDelete.html">FileDelete</a> 
</pre>
 

これにより不要ファイルの削除を行うことができます。 
[[画像:Outdata-PIONE-Advanced2-4.png|border]] 
上記の例ではOutdata.lpfを削除しています。 
 
[[画像:Outdata-PIONE-Advanced2-5.png|border]] 
削除完了画面が表示されるので、ブラウザのバックボタンで戻ります。 
 
[[画像:Outdata-PIONE-Advanced2-6.png|border]] 
画面表示を更新するとOutdata.lpfが消えていることが確認できます。また、インタラクティブ操作を終了し、ファイルをダウンロードするとOudata.lpfが無いことも確認できます。これにより不要ファイルを削除できたことが分かりました。 
 

=== 応用３（参照像の作成） ===
　今回はループ文を使用した例を示します。 
 

==== 問題３ ====
　入力ファイルを参照用の３次元画像（.ref3d）として、指定した範囲の角度で参照像（.ref2d）を作成する処理を考えます。[[PIONE Webclient]]を利用し、作成した各参照像の画像を確認しながら、ユーザ操作によって適切な角度を決定できるようにします。 
 

-----

　応用問題３：上記の機能を持つパッケージRef3DtoRef2D.ppgを作成してみましょう。

-----
 

==== 解答例 ====
===== [[PIONE定義書]] =====
　ユーザ操作によって３次元画像と投影する角度を設定し、そこから参照像を作成して、結果を画像として確認し、決定かやり直しかを選択できる流れとしています。 
 

Annotation.pione 
<pre>
.@ PackageName :: "Ref3DtoRef2D"
.@ Editor :: "Kinoshita"
.@ Tag :: "v0.2.0"
</pre>
 

Main.pione
<pre>
Rule Main
output '*.ref3d'
output '*.ref2d'
output '*.mon'
output '*.gif'
Flow
rule Start
rule SubMain
rule Result
rule Finish
End

Rule Start
output 'Start0!Flag'
Action
touch {$O[1]}
End

Rule SubMain
input 'Start*!Flag'
output '*.*'.all
Flow
rule Interaction {val : '{$I[1][1]}'.str().i()}
rule Ref3DtoRef2D {val : '{$I[1][1]}'.str().i()}
End

Rule Finish
input 'Finish*!Flag'
input '*.*-{$I[1][1]}'
output '{$I[2][1]}.{$I[2][2]}'
Action
cp {$I[2]} {$O[1]}
End
</pre>
SubMainルールにて角度と３次元画像の設定とその２次元画像の作成を実行します。このルールはStartN!Flagで発火し、最初はStartルールで、やり直すときはResultルールでそれぞれStartN!Flagを作成します。このときのNはやり直しのために設定した整数で、前に作成されたファイルとこれから作成するファイルが混ざらないようにするために設定しています。ルールFinishで決定したときのファイルのみを取り出します。 
 

Interaction.pione 
<pre>
Rule Interaction
input 'Start{$val}!Flag'
output '*.*'.all
param $val
Action
# build public directory for pione-interactive
mkdir public
cp etc/* public
cp bin/* public

# start interactive operation
pione-interactive browser --public public

cp public/* .
for file in $(ls *Mode *Rot1 *Rot2 *Rot3 *.ref3d) ;
do
mv "$file" "$file-{$val}";
done
End
</pre>
やり直しに対応できるように処理の最後で作成されたファイルに番号を付けています。 
 

Ref3DtoRef2D.pione 
<pre>
Rule Ref3DtoRef2D
input '*!*!*.!Rot1-{$val}'
input '*!*!*.!Rot2-{$val}'
input '*!*!*.!Rot3-{$val}'
input '*.!Mode-{$val}'
input '*.ref3d-{$val}'
output '*.ref2d-{$val}'.all
output 'Ref3DtoRef2D.info-{$val}'
$min1 := '{$I[1][1]}'.str().f()
$max1 := '{$I[1][2]}'.str().f()
$delta1 := '{$I[1][3]}'.str().f()
$loop1 := (($max1 - $min1) / $delta1).i()
$min2 := '{$I[2][1]}'.str().f()
$max2 := '{$I[2][2]}'.str().f()
$delta2 := '{$I[2][3]}'.str().f()
$loop2 := (($max2 - $min2) / $delta2).i()
$min3 := '{$I[3][1]}'.str().f()
$max3 := '{$I[3][2]}'.str().f()
$delta3 := '{$I[3][3]}'.str().f()
$loop3 := (($max3 - $min3) / $delta3).i()
$mode := '{$I[4][1]}'.str()
param $val
Flow
rule One3Dto2D {rot1: $min1 + ((0.upto($loop1)).f() * $delta1), rot2: $min2 + ((0.upto($loop2)).f() * $delta2), rot3: $min3 + ((0.upto($loop3)).f() * $delta3), mode : $mode, val : $val}
rule Info3Dto2D {val : $val}
End

Rule Info3Dto2D
input '*.ref2d-{$val}'.all
output 'Ref3DtoRef2D.info-{$val}'
param $val
Action
for file in $(ls *.ref2d-{$val})
do
echo "./$file" >> {$O[1]}
done
End

Rule One3Dto2D
input '*.ref3d-{$val}'
output '*.ref2d-{$val}'.all
param $rot1
param $rot2
param $rot3
param $mode
param $val
Action
output="{$I[1][1]}-{$mode}-{$rot1}-{$rot2}-{$rot3}.ref2d-{$val}"
mrc3Dto2D -i {$I[1]} -o $output \
-Rot1 {$rot1} {$rot1} 1 \
-Rot2 {$rot2} {$rot2} 1 \
-Rot3 {$rot3} {$rot3} 1 \
-EulerMode {$mode};
End
</pre>
ルールRef3DtoRef2Dは大きくFlowLoop3Dto2D1とOne3Dto2Dの２つのルールに分かれます。ここでもやり直しに対応するためにファイルの末尾に番号を付けます。ルールInfo3Dto2Dでは画像作成のために２次元画像の一覧を作成します。ルールOne3Dto2D1ではuptoによるループを利用して３次元画像から[[mrc3Dto2D]]によって２次元画像を次々に作成します。このとき３軸毎に回転角度をそれぞれuptoで設定しています。 
 

Result.pione 
<pre>
Rule Result
input 'Ref3DtoRef2D.info-*'
input '*.ref2d-{$I[1][1]}'.all
output '*!Flag'
output 'Ref3DtoRef2D.mon-{$I[1][1]}'
output 'Ref3DtoRef2D.gif-{$I[1][1]}'
Flow
rule Ref2DtoGIF {val : '{$I[1][1]}'.str().i()}
rule ResultCheck {val : '{$I[1][1]}'.str().i()}
End

Rule Ref2DtoGIF
input 'Ref3DtoRef2D.info-{$val}'
input '*.ref2d-{$val}'.all
output 'Ref3DtoRef2D.mon-{$val}'
output 'Ref3DtoRef2D.gif-{$val}'
param $val
Action
mrcImageMontageCreate -i {$I[1]} -o {$O[1]}
mrc2gif -i {$O[1]} -o {$O[2]}
End

Rule ResultCheck
input 'Ref3DtoRef2D.gif-{$val}'
output '*!Flag'
param $val
Action
# build public directory for pione-interactive
mkdir public
cp etc/index2.html public/index.html
cp bin/* public
cp {$I[1]} public/Ref3DtoRef2D.gif

# start interactive operation
pione-interactive browser --public public

cp public/* .
if [ -e "Finish!Flag" ]; then
mv "Finish!Flag" "Finish{$val}!Flag";
elif [ -e "Start!Flag" ]; then
mv "Start!Flag" "Start{$val + 1}!Flag";
fi
End
</pre>
ルールResultはRef2DtoGIFとResultCheckに分かれます。ルールRef2DtoGIFでは各２次元像をひとまとめにしたgif画像を作成します。ルールResultCheckではgif画像をindex2.htmlのページに表示して、ユーザ操作にて決定のときはFinishN!Flagをやり直しのときはStartN!Flagを作成するようにしています。 
 

===== [[html]]ファイル =====
index.html 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>InteractiveCommand Index Page</title>
</head>
<body>
<a href="Ref3DtoRef2D.html">Ref3DtoRef2D</a> 
 
<a href="?pione-action=finish">終了</a>
</body>
</html>
</pre>
 

Ref3DtoRef2D.html 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Ref3DtoRef2D</title>
</head>
<body>
<form action="Ref3DtoRef2D.cgi" method="post" enctype="multipart/form-data">
<button type="submit">開始</button>
 
<table>
<tr>
<td>
<input type="file" name="InputFile"/>
</td>
<td>
入力ファイル名(.ref3d)
</td>
</tr>
<tr>
<td>
<select name="Mode1">
<option value="X">X</option>
<option value="Y">Y</option>
<option value="Z">Z</option>
</select>
<select name="Mode2">
<option value="O">O</option>
<option value="E">E</option>
</select>
<select name="Mode3">
<option value="Y">Y</option>
<option value="N">N</option>
</select>
<select name="Mode4">
<option value="S">S</option>
<option value="R">R</option>
</select>
</td>
<td>
回転モード
</td>
</tr>
</table>
<table>
<tr>
<td>

</td>
<td>
最小値
</td>
<td>
最大値
</td>
<td>
加算値
</td>
</tr>
<tr>
<td>
角度１
</td>
<td>
<input type="text" name="RotMin1" value="0"/>
</td>
<td>
<input type="text" name="RotMax1" value="359"/>
</td>
<td>
<input type="text" name="RotDelta1" value="30"/>
</td>
</tr>
<tr>
<td>
角度２
</td>
<td>
<input type="text" name="RotMin2" value="0"/>
</td>
<td>
<input type="text" name="RotMax2" value="359"/>
</td>
<td>
<input type="text" name="RotDelta2" value="30"/>
</td>
</tr>
<tr>
<td>
角度３
</td>
<td>
<input type="text" name="RotMin3" value="0"/>
</td>
<td>
<input type="text" name="RotMax3" value="0"/>
</td>
<td>
<input type="text" name="RotDelta3" value="30"/>
</td>
</tr>
</table>
</form>
 
 
<a href="index.html">戻る</a> 
<a href="?pione-action=finish">終了</a> 
</body>
</html>
</pre>
このページでは入力ファイルと回転モードと及び各角度毎の最小値、最大値、加算値を設定して実行できるようにしています。 
 

index2.html 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>InteractiveCommand Index Page</title>
</head>
<body>
<img src="Ref3DtoRef2D.gif"> 
 
<form action="Result.cgi" method="post" enctype="multipart/form-data">
<button type="submit">決定</button> 
<input type="hidden" name="Result" value="Finish"/>
</form>
<form action="Result.cgi" method="post" enctype="multipart/form-data">
<button type="submit">やり直し</button> 
<input type="hidden" name="Result" value="Start"/>
</form>
</body>
</html>
</pre>
これはルールResultのときに画像を確認しながら、決定かやり直しかを選択するためのページです。 
 

===== [[cgi]]ファイル =====
Ref3DtoRef2D.cgi 
<pre>
#!/usr/bin/env ruby

require 'cgi'

cgi = CGI.new

### Header
strHTML = ""
strHTML += "<!DOCTYPE html>"
strHTML += "<html>"
strHTML += "<head>"
strHTML += "<title>Ref3DtoRef2D</title>"
### Auto Close
strHTML += '<meta http-equiv="REFRESH" content="0;URL=?pione-action=finish">'

# Main Process

## Query to Parameters

### Copy InputFile
fpQueryInputFile = cgi.params['InputFile'][0]
strInputFile = fpQueryInputFile.original_filename
fpInputFile = open(strInputFile, "wb")
fpInputFile.write(fpQueryInputFile.read)
fpInputFile.close

### Other Query
strMode = cgi['Mode1'] + cgi['Mode2'] + cgi['Mode3'] + cgi['Mode4']
strRotMin1 = cgi['RotMin1']
strRotMax1 = cgi['RotMax1']
strRotDelta1 = cgi['RotDelta1']
strRotMin2 = cgi['RotMin2']
strRotMax2 = cgi['RotMax2']
strRotDelta2 = cgi['RotDelta2']
strRotMin3 = cgi['RotMin3']
strRotMax3 = cgi['RotMax3']
strRotDelta3 = cgi['RotDelta3']

### Set Parameter to FileNames
strParamFile = strMode + ".!Mode"
command = "touch " + strParamFile
system(command)

strParamFile = strRotMin1 + "!" + strRotMax1 + "!" + strRotDelta1 + ".!Rot1"
command = "touch " + strParamFile
system(command)

strParamFile = strRotMin2 + "!" + strRotMax2 + "!" + strRotDelta2 + ".!Rot2"
command = "touch " + strParamFile
system(command)

strParamFile = strRotMin3 + "!" + strRotMax3 + "!" + strRotDelta3 + ".!Rot3"
command = "touch " + strParamFile
system(command)

command = "cp " + strInputFile + " Refer.ref3d"
system(command)

strHTML += "</head>"
strHTML += "</html>"

# Output as html
cgi.out(type: "text/html") do
strHTML
end
</pre>
Ref3DtoRef2D.htmlで設定したデータをファイルに保存します。処理後は自動的にインタラクティブ操作を終了し、以降は[[PIONE]]にてルールRef3DtoRef2Dを実行します。 
 

<pre>
#!/usr/bin/env ruby

require 'cgi'

cgi = CGI.new

### Header
strHTML = ""
strHTML += "<!DOCTYPE html>"
strHTML += "<html>"
strHTML += "<head>"
strHTML += "<title>Result</title>"
### Auto Close
strHTML += '<meta http-equiv="REFRESH" content="0;URL=?pione-action=finish">'

# Main Process
## Query to Parameters
Result = cgi['Result']

command = "touch " + Result + "!Flag"
system(command)

strHTML += "</head>"
strHTML += "</html>"

# Output as html
cgi.out(type: "text/html") do
strHTML
end
</pre>
index2.htmlの操作によって、決定またはやり直しを選択したときの処理です。決定のときはFinish!Flag、やり直しのときはStart!FLagを作成します。処理後は自動的にインタラクティブ操作を終了します。 
 

これらのファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Advanced3 こちら]からダウンロードできます。 
 

==== [[パッケージ作成]] ====
コードが完成したら[[パッケージ作成]]を行います。 
<pre>
/PIONE$ pione package build Advanced3
info: update the package info file: local:/Eos/tutorial/SampleCode/PIONE/Advanced3/pione-package.json
info: Package local:/Eos/tutorial/SampleCode/PIONE/Ref3DtoRef2D(Kinoshita)+v0.1.1.ppg has been built successfully.
</pre>
 

==== 実行結果 ====
では、動作させてみましょう。 
[[PIONE Webclient]]のジョブページで実行し、Interactionを選択してindexページを開きます。ここでRef3DtoRef2Dを選択すると設定画面が表示されます。 

今回は[[Media:1VOM.mrc|下記の入力ファイル]]を３次元像として２次元画像を作成してみます。 
<table>
<tr>
<td>[[画像:Input-1VOM.png]] 
xy平面 
</td>
<td>[[画像:Input1-1VOM.png]] 
yz平面 
</td>
<td>最小 
最大 
平均値 
標準偏差 
標準誤差 
</td>
<td>0 (0, 0, 0) 
3398.12 (23, 55, 41) 
72.129 
294.805 
0.368507 
</td>
</tr>
</table>
 

[[画像:Outdata-PIONE-Advanced3-1.png|border]] 
入力ファイル及び回転のモード（参照: [[オイラー角]]）、角度の範囲を設定して開始ボタンを押します。 
 

[[画像:Outdata-PIONE-Advanced3-2.png|border]] 
すると、上記のようにインタラクティブ操作は完了して、再び[[PIONE]]にて２次元像の作成処理が動きます。（このページは閉じて構いません） 
 

[[画像:Outdata-PIONE-Advanced3-3.png|border]] 
再びInteractionボタンが赤色になりますので、開くと作成された２次元像の一覧が画像にて表示されます。この内容を見ながら「決定」か「やり直し」を選択します。 
 

[[画像:Outdata-PIONE-Advanced3-2.png|border]] 
同様にインタラクティブ操作が完了しますので、ページを閉じます。 
 

[[画像:Outdata-PIONE-Advanced3-4.png|border]] 
「やり直し」を選択すると、再度設定画面を開くことができます。また、「決定」を選択するとこのときの結果がouputへ出力されます。このようにして結果を確認しながら適切な設定を選び直すことが出来ます。 
 

上記の設定で決定したときのgif画像（縮小表示） 
[[画像:Outdata-PIONE-Advanced3-5.gif|500px]] 
 

==== 補足（チケットを使ってルールを制御する） ====
設定、処理、確認のルールが同時に動いてはそれぞれの役割が満たせませんので、チケットを使用して制御を加えてみましょう。もちろん入力ファイルや出力ファイルの関係がうまく作れていれば同時に動くことはありません。今回は念のための処置として作成します。 
 

Main.pione 
<pre>
Rule Main
output '*.ref3d'
output '*.ref2d'
output '*.mon'
output '*.gif'
Flow
rule Start >>> SubMain >>> Result
rule Finish
End

Rule Start
output 'Start0!Flag'
Action
touch {$O[1]}
End

Rule SubMain
input 'Start*!Flag'
output '*.*'.all
Flow
rule Interaction {val : '{$I[1][1]}'.str().i()} >>> Ref3DtoRef2D {val : '{$I[1][1]}'.str().i()}
End

Rule Finish
input 'Finish*!Flag'
input '*.*-{$I[1][1]}'
output '{$I[2][1]}.{$I[2][2]}'
Action
cp {$I[2]} {$O[1]}
End
</pre>
MainルールとSubMainルールにて順番を指定しています。 
このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Advanced3plus1 こちら]からダウンロードできます。 
 

=== 応用４（単粒子解析） ===
　次は[[Makefile]]をベースとして[[単粒子解析]]のための処理を作ってみましょう。 
 

==== 問題４ ====
元のMakefileが下記であったとします。 
<pre>
.SUFFIXES: .roi .smooth .shrink .pad .fit .corinfo .3dinfo .3dwholeinfo .3d4sinfo .lst .3dlst .padlst .3d .ds6 .3dwholelst .3dwhole .wholeds6 .3d4s .4sds6 .3d4sinfolst

#SHELL=/bin/bash

REFERENCE=1J4Z-move-shrink.stack

.lst.padlst:
rm -f $*.padlst
for i in `cat $*.lst`; do \
FILENAME=`basename $$i .roi`; \
echo $$FILENAME; \
make $$FILENAME.pad ; \
echo $$FILENAME.pad >> $*.padlst; \
done

.padlst.3dlst:
rm -f $*.3dlst
rm -f $*.3dwholelst
for i in `cat $*.padlst`; do \
FILENAME=`basename $$i .pad`; \
make $$FILENAME.fit ; \
make $$FILENAME.3dinfo ; \
cat $$FILENAME.3dinfo >> $*.3dlst ; \
make $$FILENAME.3dwholeinfo ; \
cat $$FILENAME.3dwholeinfo >> $*.3dwholelst ; \
done

.padlst.3d4sinfolst:
rm -f $*.3d4sinfolst
for i in `cat $*.padlst`; do \
FILENAME=`basename $$i .pad`; \
make $$FILENAME.3d4sinfo ; \
cat $$FILENAME.3d4sinfo >> $*.3d4sinfolst ; \
done

.roi.smooth:
mrcImageSmoothing -i $*.roi -o $*.smooth -m 1 -r 4

.smooth.shrink:
mrcImageShrink -i $*.smooth -o $*.shrink -S 8

.shrink.pad:
mrcImagePad -i $*.shrink -o $*.pad -W 32 -H 32

.pad.fit:
mrcImageAutoRotationCorrelation -i $*.pad -r $(REFERENCE) -fit $*.fit -O $*.corinfo -n 72 -m 18 -nRot1 72 -nRot2 72 -nRot3 1 > /dev/null

.fit.3dinfo:
awk '/Cor/ { print $$18,$$16,$$2,$$3,$$4,"0.0"}' $*.corinfo | sort -r | sed -e s/pad/fit/ > $*.3dinfolst
head -n 1 $*.3dinfolst | awk ' {print $$2,$$3,$$4,$$5,$$6,$$1'} > $*.3dinfo

.fit.3dwholeinfo:
awk '/Cor/ { print $$18,$$16,$$2,$$3,$$4,$$9,$$11,$$12}' $*.corinfo | sort -r | sed -e s/pad/shift/ > $*.3dwholeinfolst
head -n 1 $*.3dwholeinfolst | awk ' {print $$2,$$3,$$4,$$5,$$6,$$7,$$8,$$1'} > $*.3dwholeinfo
X=`awk '{print -8*$$6; }' $*.3dwholeinfo`; \
Y=`awk '{print -8*$$7; }' $*.3dwholeinfo`; \
echo $$X,$$Y; mrcImageShift -i $*.roi -o $*.shift -x $$X -y $$Y -z 0

.3dlst.3d:
mrc2Dto3D -I $*.3dlst -o $*.3d -InterpolationMode 2 -Double -DoubleCounter $*.3dcounter -CounterThreshold 0.5 -m 1 -WeightMode 6

.3d.ds6:
mrc2map -i $*.3d -o $*.ds6 -m 3

.3dwholelst.3dwhole:
mrc2Dto3D -I $*.3dwholelst -o $*.3dwhole -InterpolationMode 2 -Double -DoubleCounter $*.3dwholecounter -CounterThreshold 0.5 -m 1 -WeightMode 6
.3dwhole.wholeds6:
mrc2map -i $*.3dwhole -o $*.wholeds6 -m 3
ln -sf $*.wholeds6 $*.whole.ds6

.fit.3d4sinfo:
awk '/Cor/ { print $$18,$$16,$$2,$$3,$$4,$$9,$$11,$$12}' $*.corinfo | sort -r | sed -e s/pad/shift/ > $*.3d4sinfolst
head -n 1 $*.3d4sinfolst | awk ' {print $$2,$$3,$$4,$$5,$$6,$$7,$$8,$$1'} > $*.3d4sinfo
X=`awk '{print -4*$$6; }' $*.3d4sinfo`; \
Y=`awk '{print -4*$$7; }' $*.3d4sinfo`; \
echo $$X,$$Y;
mrcImageShrink -i $*.roi -o $*.4shrink -S 4
mrcImagePad -i $*.4shrink -o $*.pad -W 64 -H 64
mrcImageShift -i $*.roi -o $*.4shift -x $$X -y $$Y -z 0

.3d4sinfolst.3d4s:
mrc2Dto3D -I $*.3d4sinfolst -o $*.3d4s -InterpolationMode 2 -Double -DoubleCounter $*.3d4scounter -CounterThreshold 0.5 -m 1 -WeightMode 6
.3d4s.4sds6:
mrc2map -i $*.3d4s -o $*.4sds6 -m 3
ln -sf $*.4sds6 $*.4s.ds6
</pre>
上記のMakefileは複数の電子顕微鏡画像(.roi)に対して、参照像を使って角度決定をした後に３次元再構成を実行する処理となっています。.roiファイルの一覧は.lstに書かれていて、参照像の2Dスタック(REFERENCEで設定)があることが前提となっています。このmakefileは相関マップ(.corinfo)を作成するときに1/8とした画像を使用することで速度の向上をはかっています。"make （.lstのファイル名）.3d"で1/8サイズ、"make （.lstのファイル名）.3dwhole"で1/1サイズ、"make （.lstのファイル名）.3d4s"で1/4サイズの３次元像が作成されます。 
 

-----

　応用問題４：上記の機能を持つパッケージSingleParticle_3DReconstruction.ppgを作成してみましょう。

-----
 

==== 解答例１ ====
解答例を一部示します。全体は[[Media:PIONE-Advanced4-1.zip|こちら]]をご覧下さい。元の機能に加えて、サンプルの.roiファイルと参照像2Dスタック.stackを作成できるようにしています。この場合の入力ファイルは.mrcのみです。さらに、作成された３次元像を画像としてすぐに確認できるように３方向からの投影像を[[gif]]ファイルで出力しています。また、機能毎にフラグを設けて作成したいデータのみを作成できるようにしています。 
 

===== 実装 =====
Main.pione 
<pre>
Rule Main
if $Flag_ROI or $Flag_Ref
input '*.mrc'
end

if $Flag_ROI.not()
input '*.lst'
input '*.roi'.all
end

if $Flag_Ref.not()
input '*.stack'
end

if $Flag_3D
output '{$I[1][1]}.3dlst'
output '{$I[1][1]}.3d'
output '{$I[1][1]}.ds6'
end

if $Flag_3DWhole
output '{$I[1][1]}.3dwholelst'
output '{$I[1][1]}.3dwhole'
output '{$I[1][1]}.wholeds6'
output '{$I[1][1]}.whole.ds6'
end

if $Flag_3D4S
output '{$I[1][1]}.3d4slst'
output '{$I[1][1]}.3d4s'
output '{$I[1][1]}.4sds6'
output '{$I[1][1]}.4s.ds6'
end

if $Flag_ROI
output '*.tiff'.all
end

output '*.gif'.all

Flow

if $Flag_ROI
rule Create_SampleROI
end

if $Flag_Ref
rule Create_stack
end

rule Preprocess
rule Create_fit

if $Flag_3D
rule Create_3dlst
rule Create_3d
end

if $Flag_3DWhole
rule Create_3dwholelst
rule Create_3dwhole
end

if $Flag_3D4S
rule Create_3d4slst
rule Create_3d4s
end

rule Projection_3d
End
</pre>
 

Main.pione内で使用しているルールは下記のようにMakefileの処理と対応しています。 
<table border="1">
<tr>
<th>Main.pione内のルール</th>
<th>サブルール</th>
<th>Makefile</th>
<th>説明</th>
</tr>
<tr>
<td>Create_SampleROI</td>
<td>-</td>
<td>なし</td>
<td>サンプル用の.roiファイルを複数作成</td>
</tr>
<tr>
<td>Create_stack</td>
<td>-</td>
<td>なし</td>
<td>参照像の2Dスタック.stackファイルを作成</td>
</tr>
<tr>
<td>Preprocess</td>
<td>pad_padlst 
roi_smooth 
smooth_shrink 
shrink_pad 
</td>
<td>.lst.padlst 
.roi.smooth 
.smooth.shrink 
.shrink.pad 
</td>
<td>.padファイル一覧を作成 
.roiの平滑化して.smoothを作成 
.smoothを縮小して.shrinkを作成 
.shrinkを参照画像と同じサイズにパディングして.padを作成 
</td>
</tr>
<tr>
<td>Create_fit</td>
<td>-</td>
<td>.pad.fit</td>
<td>.padから.stackを使って相関マップ.corinfoを作成（最も近い画像.fitも作成）</td>
</tr>
<tr>
<td>Create_3dlst</td>
<td>fit_3dinfo 
Sum_3dinfo_3dlst</td>
<td>.fit.3dinfo</td>
<td>各相関マップ.corinfoから相関値が最大の角度を集めてリスト.3dlstを作成</td>
</tr>
<tr>
<td>Create_3d</td>
<td>Reconstruct_3dlst_3d 
Convert_3d_ds6</td>
<td>.3dlst.3d 
.3d.ds6</td>
<td>リスト.3dlstと.fitを使って３次元像.3d及び.ds6を作成（1/8サイズ）</td>
</tr>
<tr>
<td>Create_3dwholelst</td>
<td>fit_3dwholeinfo 
Sum_3dwholeinfo_3dwholelst</td>
<td>.fit.3dwholeinfo</td>
<td>Create_3dlstの1/1サイズバージョン</td>
</tr>
<tr>
<td>Create_3dwhole</td>
<td>Reconstruct_3dwholelst_3dwhole 
Convert_3dwhole_wholeds6</td>
<td>.3dwholelst.3dwhole 
.3dwhole.wholeds6</td>
<td>Create_3dの1/1サイズバージョン</td>
</tr>
<tr>
<td>Create_3d4slst</td>
<td>fit_3d4sinfo 
Sum_3d4sinfo_3d4slst</td>
<td>.fit.3d4sinfo</td>
<td>Create_3dlstの1/4サイズバージョン</td>
</tr>
<tr>
<td>Create_3d4s</td>
<td>Reconstruct_3d4slst_3d4s 
Convert_3d4s_4sds6</td>
<td>.3d4sinfolst.3d4s 
.3d4s.4sds6</td>
<td>Create_3dの1/4サイズバージョン</td>
</tr>
<tr>
<td>Projection_3d</td>
<td>-</td>
<td>なし</td>
<td>作成された３次元像.3dなどを3方向から投影したgif画像を作成</td>
</tr>
</table>
 

また、下記のように画像サイズや回転方法をパラメータにて設定できるようにしています。 
 

Parameter.pione 
<pre>
# basic param
## For Size
param $X_SIZE := 80
param $Y_SIZE := 80
param $SHRINK := 8
param $SHRINK4S := 4

## For AutoRotationCorrelation
param $N_ROT := 72
param $N_ROT1 := 72
param $N_ROT2 := 72
param $N_ROT3 := 1

## For RefData
param $REF_ROT_MODE := "XOYS"
param $REF_ROT1_START := 0
param $REF_ROT1_END := 359
param $REF_ROT1_DELTA := 15
param $REF_ROT2_START := 0
param $REF_ROT2_END := 359
param $REF_ROT2_DELTA := 15
param $REF_ROT3_START := 0
param $REF_ROT3_END := 0
param $REF_ROT3_DELTA := 15

## For SampleROI
param $ROI_ROT_MODE := "XOYS"
param $ROI_ROT1_START := 0
param $ROI_ROT1_END := 359
param $ROI_ROT1_DELTA := 30
param $ROI_ROT2_START := 0
param $ROI_ROT2_END := 359
param $ROI_ROT2_DELTA := 30
param $ROI_ROT3_START := 0
param $ROI_ROT3_END := 0
param $ROI_ROT3_DELTA := 30
param $ROI_SN := 1

# advanced param
advanced param $Flag_ROI := true
advanced param $Flag_Ref := true
advanced param $Flag_3D := true
advanced param $Flag_3DWhole := true
advanced param $Flag_3D4S := true
</pre>
 

===== Makefile との動作比較 =====
作成した[[PIONE定義書]]と元の[[Makefile]]との処理時間を比較して、ここまでの実装の効果があったかを検証します。今回は.3dファイルの作成に関して比較します。 
 

.roiファイルと.stackファイルは予めParameter.pioneを下記のようにして作成しています。（[[ROI]]画像: サイズ256×256, 2つの角度0 ~ 300: 60刻み） 
<pre>
param $X_SIZE := 256 #80
param $Y_SIZE := 256 #80

param $ROI_ROT1_START := 0
param $ROI_ROT1_END := 359
param $ROI_ROT1_DELTA := 60 #30

param $ROI_ROT2_START := 0
param $ROI_ROT2_END := 359
param $ROI_ROT2_DELTA := 60 #30

param $ROI_ROT3_START := 0
param $ROI_ROT3_END := 0
param $ROI_ROT3_DELTA := 30

advanced param $Flag_ROI := true
advanced param $Flag_Ref := true
advanced param $Flag_3D := false
advanced param $Flag_3DWhole := false
advanced param $Flag_3D4S := false
</pre>
 

[[Media:1VOM.mrc|.roiや.stack作成で使用する.mrcファイル]] 
<table>
<tr>
<td>[[画像:Input-1VOM.png]] 
xy平面 
</td>
<td>[[画像:Input1-1VOM.png]] 
yz平面 
</td>
<td>最小 
最大 
平均値 
標準偏差 
標準誤差 
</td>
<td>0 (0, 0, 0) 
3398.12 (23, 55, 41) 
72.129 
294.805 
0.368507 
</td>
</tr>
</table>
 

作成された[[ROI]]ファイルの一覧をData.lstに書き込んで[[Makefile]]で動作できるようにします。また、Makefile内にてREFERENCEを作成した.stackファイル名に変更します。 
<pre>
#REFERENCE=1J4Z-move-shrink.stack
REFERENCE=1WDC.stack
</pre>
以上の.roiファイル、.stackファイル、Makefileを入力用のディレクトリに置きます。 
 

Makefileの処理時間の下記の[[PIONE定義書]]を作って、計測しています。 
計測①コード 
<pre>
Rule Main
input '*.lst'
input '*.roi'.all
input 'Makefile'
input '*.stack'.all
output '{$I[1][1]}.ds6'
Action
make {$O[1]}
End
</pre>
上記のルールの場合、（全体の処理）＝（Makefile処理）＋（入力ファイル処理）＋（出力ファイル処理）となっているので、下記の計測②時間との差分を算出すれば、およそのMakefileの処理時間が算出できます。 
 

計測②コード 
<pre>
Rule Main
input '*.lst'
input '*.roi'.all
input 'Makefile'
input '*.stack'.all
input '*.ds6'
output '{$I[5][1]}.ds6out'
Action
cp {$I[5]} {$O[1]}
End
</pre>
 

計測①結果（９分強） 
[[画像:Outdata-PIONE-Advanced4-12.png]] 
 

計測②結果（１秒程度） 
[[画像:Outdata-PIONE-Advanced4-13.png]] 
 

計測①が９分強、計測②が１秒程度なので、Makefileの処理時間は９分強掛かったことが分かりました。 
 

では、[[:Media:PIONE-Advanced4-1.zip|今回実装した処理]]をタスク数２（-t 2）で実行してみます。 
 

-t 2の結果（７分程度） 
[[画像:Outdata-PIONE-Advanced4-16.png]] 
今回の実装においては２分程度の削減で、処理時間がMakefileの7/9となりました。しかし、この実装においてルールを細かく分けすぎているためにルール間の入出力ファイルのやり取りによる処理が各所で発生しています。次の項目にてこれらの無駄を省くためのコーディングを考えて、さらに時間を削減してみましょう。 
 

==== 速度アップのための実装 ====
===== リスト作成の省略 =====
まずは.lstなどを作成している部分について考えます。[[PIONE]]は１：複数の処理が可能ですのでリストの作成は省略できます。 
 

Main.pione 
<pre>
Rule Main
if ($Mode_ROI + $Mode_Ref) != 0
input '*.mrc'
end

if $Mode_Ref == 0
input '*.stack'
end

if $Mode_ROI == 0
input '*.roi'.all
end

if $Flag_3D
output '{$I[1][1]}.3dlst'
output '{$I[1][1]}.3d'
output '{$I[1][1]}.ds6'
end

if $Flag_3DWhole
output '{$I[1][1]}.3dwholelst'
output '{$I[1][1]}.3dwhole'
output '{$I[1][1]}.wholeds6'
output '{$I[1][1]}.whole.ds6'
end

if $Flag_3D4S
output '{$I[1][1]}.3d4slst'
output '{$I[1][1]}.3d4s'
output '{$I[1][1]}.4sds6'
output '{$I[1][1]}.4s.ds6'
end

if $Mode_ROI != 0
output '*.tiff'.all
end

if $Flag_Projection
output '*.gif'.all
end
Flow
case $Mode_ROI
when 1
rule Create_Sample3d
rule Create_SampleROI_each {rot1: (0.upto($roi_rot1_loop))*$ROI_ROT1_DELTA, rot2: (0.upto($roi_rot2_loop))*$ROI_ROT2_DELTA, rot3: (0.upto($roi_rot3_loop))*$ROI_ROT3_DELTA}
when 2
rule Create_Sample3d
rule Create_SampleROI_all
end

if $Mode_Ref != 0
rule Create_stack
end

rule Preprocess

case $Mode_Cor
when 1
rule Create_fit_each
when 2
rule Create_fit_all
end

if $Flag_3D
rule Create_3dlst {filename: $I[1][1].str()}
rule Create_3d
end

if $Flag_3DWhole
rule Create_3dwholelst {filename: $I[1][1].str()}
rule Create_3dwhole
end

if $Flag_3D4S
rule Create_3d4slst {filename: $I[1][1].str()}
rule Create_3d4s
end

if $Flag_Projection
rule Projection_3d
end
End
</pre>
.roiファイル、.padファイルの一覧を記述した.lstファイル.padlstファイルを廃止して、入力用ディレクトリにある全ての.roiファイルについて処理を行うように変更しました。（但し、.3dlstなどは角度情報として使用するのでそのまま）また、入力ファイル１つに対して複数のファイルを作成する箇所についてeachで行うかallで行うかをパラメータによって決められるようにしています。今回の場合はeachを使用して複数のタスクで実行すると速度の改善が期待できます。（参照：[[#基本４の補足（eachでの速度検証）]]） 
 

allで実行した場合（約65秒） 
[[画像:Outdata-PIONE-Advanced4-7.png|1120px]] 
 

eachで実行した場合（約81秒）（allよりも時間が掛かっている） 
[[画像:Outdata-PIONE-Advanced4-8.png|1390px]] 
 

eachを-t 2で実行した場合（約47秒）（速度が改善されている） 
[[画像:Outdata-PIONE-Advanced4-9.png|820px]] 
 

eachを-t 3で実行した場合（約36秒）（さらに速度が改善されている） 
[[画像:Outdata-PIONE-Advanced4-10.png|635px]] 
 

eachを-t 4で実行した場合（約31秒）（若干速度が改善されている） 
[[画像:Outdata-PIONE-Advanced4-11.png|550px]] 
 

上記は１つのマシンにおいてallと複数のタスクによるeachの速度の違いです。eachを複数のタスクで動作させると、allの場合よりも速く処理できることが分かります。そして、タスク数が多いほどが速度が改善されています。しかし、タスク数を増やす毎に改善の度合いは緩やかになっています。マシン毎で一度に処理できるタスク数を把握し、全てのタスクをいくつに分けるかを考えると良いでしょう。 
 

Param.pione 
<pre>
# basic param
## For Size
param $X_SIZE := 80
param $Y_SIZE := 80
param $SHRINK := 8
param $SHRINK4S := 4

## For AutoRotationCorrelation
param $N_ROT := 72
param $N_ROT1 := 72
param $N_ROT2 := 72
param $N_ROT3 := 1

## For RefData
param $REF_ROT_MODE := "XOYS"
param $REF_ROT1_START := 0
param $REF_ROT1_END := 359
param $REF_ROT1_DELTA := 15
param $REF_ROT2_START := 0
param $REF_ROT2_END := 359
param $REF_ROT2_DELTA := 15
param $REF_ROT3_START := 0
param $REF_ROT3_END := 0
param $REF_ROT3_DELTA := 15

## For SampleROI
param $ROI_ROT_MODE := "XOYS"
param $ROI_ROT1_START := 0
param $ROI_ROT1_END := 359
param $ROI_ROT1_DELTA := 30
$roi_rot1_loop := ($ROI_ROT1_END - $ROI_ROT1_START) / $ROI_ROT1_DELTA
param $ROI_ROT2_START := 0
param $ROI_ROT2_END := 359
param $ROI_ROT2_DELTA := 30
$roi_rot2_loop := ($ROI_ROT2_END - $ROI_ROT2_START) / $ROI_ROT2_DELTA
param $ROI_ROT3_START := 0
param $ROI_ROT3_END := 0
param $ROI_ROT3_DELTA := 30
$roi_rot3_loop := ($ROI_ROT3_END - $ROI_ROT3_START) / $ROI_ROT3_DELTA
param $ROI_SN := 1

# advanced param
## Mode 0: do not, 1: each, 2: all
advanced param $Mode_ROI := 1
advanced param $Mode_Ref := 1
advanced param $Mode_Cor := 1
## Flag true: do, false: do not
advanced param $Flag_3D := true
advanced param $Flag_3DWhole := true
advanced param $Flag_3D4S := true
advanced param $Flag_Projection := true
</pre>
今回はMode_ROIとMode_Corのみ1: each, 2: allの切り替えが可能としています。$roi_rot1_loopなどの[[変数束縛]]を追加していますが、これはeachのループ数のためでユーザが入力する必要はありません。 
 

これらのファイルは[[Media:PIONE-Advanced4-2.zip|こちら]]からダウンロードできます。 
 

===== 同じようなルールをまとめる =====
====== Preprocess ======
Mainで呼んでいるPreprocessのルールは下記のようにしていました。 
<table border="1">
<tr>
<th>Main.pione内のルール</th>
<th>サブルール</th>
<th>Makefile</th>
<th>説明</th>
</tr>
<tr>
<td>Preprocess</td>
<td>pad_padlst 
roi_smooth 
smooth_shrink 
shrink_pad 
</td>
<td>.lst.padlst 
.roi.smooth 
.smooth.shrink 
.shrink.pad 
</td>
<td>.padファイル一覧を作成 
.roiの平滑化して.smoothを作成 
.smoothを縮小して.shrinkを作成 
.shrinkを参照画像と同じサイズにパディングして.padを作成 
</td>
</tr>
</table>
 

これらの処理は全て入力ファイルと出力ファイルが１：１対応であり、.roi -> .smooth -> .shrinkの順番に作成して最終的に.padファイルのみを得ることを目的としています。このような場合はルールを分けずに１つのルールの中で処理を行った方がルール間のファイルのやり取りが最小限で済みます。（参照：[[#基本５の補足]]） 
 

<table border="1">
<tr>
<th></th>
<th>コード</th>
<th>処理結果（[[ProM]]）</th>
</tr>
<tr>
<td>(1) 分けた場合</td>
<td>
<pre>
Rule Preprocess
input '*.roi'
output '{$I[1][1]}.pad'
Flow
rule roi_smooth;
rule smooth_shrink;
rule shrink_pad;
End

#.roi.smooth:
Rule roi_smooth
input '*.roi'
output '{$I[1][1]}.smooth'
Action
mrcImageSmoothing -i {$I[1]} -o {$O[1]} -m 1 -r 4
End

#.smooth.shrink:
Rule smooth_shrink
input '*.smooth'
output '{$I[1][1]}.shrink'
Action
mrcImageShrink -i {$I[1]} -o {$O[1]} -S {$SHRINK}
End

#.shrink.pad:
Rule shrink_pad
input '*.shrink'
output '{$I[1][1]}.pad'
Action
width=`expr {$X_SIZE} / {$SHRINK}`
height=`expr {$Y_SIZE} / {$SHRINK}`
mrcImagePad -i {$I[1]} -o {$O[1]} -W ${width} -H ${height}
End
</pre>
</td>
<td>[[画像:Outdata-PIONE-Advanced4-5.png]]</td>
</tr>
<tr>
<td>(2) まとめた場合</td>
<td>
<pre>
Rule Preprocess
input '*.roi'
output '{$I[1][1]}.pad'
Action
# roi_smooth
mrcImageSmoothing -i {$I[1]} -o {$I[1][1]}.smooth -m 1 -r 4

# smooth_shrink
mrcImageShrink -i {$I[1][1]}.smooth -o {$I[1][1]}.shrink -S {$SHRINK}

# shrink_pad
width=`expr {$X_SIZE} / {$SHRINK}`
height=`expr {$Y_SIZE} / {$SHRINK}`
mrcImagePad -i {$I[1][1]}.shrink -o {$O[1]} -W ${width} -H ${height}
End
</pre>
</td>
<td>[[画像:Outdata-PIONE-Advanced4-6.png|540px]]</td>
</tr>
</table>
 

上記の(2)のようにルールをまとめることで(1)に比べて、１ファイル毎に１秒ほど時間が短縮できました。 
 

====== Create_fit, Create_3dlst, Create_3d ======
　Create_fitは各.padファイルから.fitファイルや.corinfoファイルをそれぞれ１：１で作成しています。また、Create_3dlstでもfit_3dinfoまでは１：１対応の処理です。 

<table border="1">
<tr>
<th>Main.pione内のルール</th>
<th>サブルール</th>
<th>Makefile</th>
<th>説明</th>
</tr>
<tr>
<td>Create_fit</td>
<td>-</td>
<td>.pad.fit</td>
<td>.padから.stackを使って相関マップ.corinfoを作成（最も近い画像.fitも作成）</td>
</tr>
<tr>
<td>Create_3dlst</td>
<td>fit_3dinfo 
Sum_3dinfo_3dlst</td>
<td>.fit.3dinfo</td>
<td>各相関マップ.corinfoから相関値が最大の角度を集めてリスト.3dlstを作成</td>
</tr>
<tr>
<td>Create_3d</td>
<td>Reconstruct_3dlst_3d 
Convert_3d_ds6</td>
<td>.3dlst.3d 
.3d.ds6</td>
<td>リスト.3dlstと.fitを使って３次元像.3d及び.ds6を作成（1/8サイズ）</td>
</tr>
</table>
 

従って、この部分もまとめた方が良いでしょう。同様にfit_3dwholeinfoとfit_3d4sinfoもまとめます。この処理は前項目のPreprocessともまとめられそうですが、[[単粒子解析]]のための３次元再構成では角度決定処理を繰り返し行うので、この部分は分けて実装します。（参照：[[単粒子解析#繰り返し（精密化）]]）また、Create_3dlstのSum_3dinfo_3dlstとCreate_3dなども一つにまとめられます。 
 

まとめたCreate_fit_each 
<pre>
Rule Create_fit_each
input '*.pad'
input '*.stack'
if ($Flag_3DWhole or $Flag_3D4S)
input '{$I[1][1]}.roi'
end
if $Flag_3D
output '{$I[1][1]}.fit'
output '{$I[1][1]}.3dinfo'
end
if $Flag_3DWhole
output '{$I[1][1]}.shift'
output '{$I[1][1]}.3dwholeinfo'
end
if $Flag_3D4S
output '{$I[1][1]}.4shift'
output '{$I[1][1]}.3d4sinfo'
end
Action
# Create_fit
mrcImageAutoRotationCorrelation -i {$I[1]} -r {$I[2]} -fit {$I[1][1]}.fit -O {$I[1][1]}.corinfo \
-n {$N_ROT} -m 18 -nRot1 {$N_ROT1} -nRot2 {$N_ROT2} -nRot3 {$N_ROT3} > /dev/null

# fit_3dinfo
if {$Flag_3D} ; then
awk '/Cor/ { print $18,$16,$2,$3,$4,"0.0"}' {$I[1][1]}.corinfo | sort -r | sed -e s/pad/fit/ > {$I[1][1]}.3dinfolst
head -n 1 {$I[1][1]}.3dinfolst | awk ' {print $2,$3,$4,$5,$6,$1'} > {$I[1][1]}.3dinfo
fi

# fit_3dwholeinfo
if {$Flag_3DWhole} ; then
awk '/Cor/ { print $18,$16,$2,$3,$4,$9,$11,$12}' {$I[1][1]}.corinfo | sort -r | sed -e s/pad/shift/ > {$I[1][1]}.3dwholeinfolst
head -n 1 {$I[1][1]}.3dwholeinfolst | awk ' {print $2,$3,$4,$5,$6,$7,$8,$1'} > {$I[1][1]}.3dwholeinfo
X=`awk '{print -{$SHRINK}*$6; }' {$I[1][1]}.3dwholeinfo`;
Y=`awk '{print -{$SHRINK}*$7; }' {$I[1][1]}.3dwholeinfo`;
echo $X,$Y; mrcImageShift -i {$I[1][1]}.roi -o {$I[1][1]}.shift -x $X -y $Y -z 0
fi

# fit_3d4sinfo
if {$Flag_3D4S} ; then
awk '/Cor/ { print $18,$16,$2,$3,$4,$9,$11,$12}' {$I[1][1]}.corinfo | sort -r | sed -e s/pad/4shift/ > {$I[1][1]}.3d4sinfolst
head -n 1 {$I[1][1]}.3d4sinfolst | awk ' {print $2,$3,$4,$5,$6,$7,$8,$1'} > {$I[1][1]}.3d4sinfo
X=`awk '{print -{$SHRINK4S}*$6; }' {$I[1][1]}.3d4sinfo`;
Y=`awk '{print -{$SHRINK4S}*$7; }' {$I[1][1]}.3d4sinfo`;
echo $X,$Y;
mrcImageShrink -i {$I[1][1]}.roi -o {$I[1][1]}.4shrink -S {$SHRINK4S}
width=`expr {$X_SIZE} / {$SHRINK4S}`
height=`expr {$Y_SIZE} / {$SHRINK4S}`
mrcImagePad -i {$I[1][1]}.4shrink -o {$I[1][1]}.4spad -W ${width} -H ${height}
mrcImageShift -i {$I[1][1]}.4spad -o {$I[1][1]}.4shift -x $X -y $Y -z 0
fi
End
</pre>
 

まとめたCreate_3d
<pre>
Rule Create_3d
input '*.3dinfo'.all
input '*.fit'.all
output '{$filename}.3d'
output '{$filename}.ds6'
param $filename
Action
# Sum_3dinfo_3dlst
for info in {$I[1]}
do
cat $info >> {$filename}.3dlst
done

# Reconstruct_3dlst_3d
mrc2Dto3D -I {$filename}.3dlst -o {$O[1]} -InterpolationMode 2 -Double -DoubleCounter {$filename}.3dcounter -CounterThreshold 0.5 -m 1 -WeightMode 6

# Convert_3d_ds6
mrc2map -i {$O[1]} -o {$O[2]} -m 3
End
</pre>
Create_3d4s, Create_3dwholeについても同様にまとめています。 
 

===== 動作比較 =====
作成した[[PIONE定義書]]と前回分や元の[[Makefile]]との処理時間を比較して、ここまでの実装の効果があったかを検証します。今回は.3dファイルの作成に関して比較します。 
 

では、[[:Media:PIONE-Advanced4-3.zip|今回の実装]]による処理時間を複数のタスク（-t 2と-t 4）で実行してみます。 
 

-t 2の結果（５分強） 
[[画像:Outdata-PIONE-Advanced4-14.png]] 
 

-t4の結果（３分強） 
[[画像:Outdata-PIONE-Advanced4-15.png]] 
 

１つのマシンにおいて２つのタスクに分けることで４分削減して約5/9（改善前からは２分削減して約5/7）になりました。さらに４つのタスクに分けることで６分削減して約1/3になりました。入力ファイル（256×256：36枚）の場合において、今回の実装で有効な並列処理ができたと言えるでしょう。 
 

==== 機能追加のための実装 ====
今回は作成した[[PIONE定義書]]や[[パッケージ]]についてさらに機能を追加する方法を考えます。 
 

===== 粒子の切り出しを追加する =====
.roiファイルが無い場合にユーザが切り出した画像を使用できるように追加してみましょう。（参照：[[単粒子解析#電子顕微鏡画像から粒子画像の抽出]]） 
 

この機能は.roiファイルを作成するものなので、Create_ROIと同列と考えて、$Mode_ROIに3を追加してこのときにユーザが切り出すようにします。 
 

Main.pione（Cutout_ROIを追加） 
<pre>
case $Mode_ROI
when 1
rule Create_Sample3d
rule Create_SampleROI_each {rot1: (0.upto($roi_rot1_loop))*$ROI_ROT1_DELTA, rot2: (0.upto($roi_rot2_loop))*$ROI_ROT2_DELTA, rot3: (0.upto($roi_rot3_loop))*$ROI_ROT3_DELTA}
when 2
rule Create_Sample3d
rule Create_SampleROI_all
when 3
rule Cutout_ROI
end
</pre>
 

Parameter.pione（コメントを追加） 
<pre>
## Mode 0: do not, 1: each, 2: all, 3: use Display2
advanced param $Mode_ROI := 3
</pre>
 

Create_SampleROI.pione（Cutout_ROIを追加） 
<pre>
Rule Cutout_ROI
input '*.mrc'
output '*.roi'.all
output '*.tiff'.all
Action
Display2 -i {$I[1]}
for data in $(ls *.roi)
do
mrc2tiff -i ${data} -o ${data}.tiff
done
End
</pre>
切り出しには[[Display2]]を使用しています。 
 

新しいルールを作成して、呼び出すだけで簡単に機能を追加することができました。 
 

===== 繰り返し機能を追加する =====
[[単粒子解析]]のための３次元再構成は出来上がった３次元像を参照像として繰り返して、３次元像の精密化を行うこともあります。今回はこの部分の対応を作成してみましょう。 
 

Parameter.pione（繰り返し回数を追加） 
<pre>
## For repeat count
param $Repeat_Count := 2
</pre>
 

Repeat_3d 
<pre>
Rule Repeat_3d
input '*-{$count}.3d'
output '{$I[1][1]}-{$count + 1}.stack'
param $count
Action
mrc3Dto2D -i {$I[1]} -o {$O[1]} -m 1 -InterpolationMode 2 -EulerMode {$REF_ROT_MODE} \
-Rot1 {$REF_ROT1_START} {$REF_ROT1_END} {$REF_ROT1_DELTA} \
-Rot2 {$REF_ROT2_START} {$REF_ROT2_END} {$REF_ROT2_DELTA} \
-Rot3 {$REF_ROT3_START} {$REF_ROT3_END} {$REF_ROT3_DELTA}
End
</pre>
上記のように作成された.3dファイルから.stackファイルを作成します。このとき繰り返し回数が分かるようにファイル名にを付加しています。また、下記のルールについても繰り返し回数の対応を行います。 
 

Create_stack.pione 
<pre>
output '{$I[1][1]}-1.stack'
</pre>
 

Main.pione（出力ファイルの宣言） 
<pre>
if $Flag_3D
output '{$I[1][1]}-{$Repeat_Count}.3d'
output '{$I[1][1]}-{$Repeat_Count}.ds6'
end
</pre>
繰り返しの最後のファイルのみを出力するようにします。 
 

Main.pione（Flow） 
<pre>
case $Mode_3D
when 1
rule Create_fit_each

if $Flag_3D
rule Create_3d {filename: $I[1][1].str(), count: 1.upto($Repeat_Count)}
rule Repeat_3d {count: 1.upto($Repeat_Count - 1)}
end
</pre>
Create_3d, Repeat_3dを繰り返し回数分呼び出します。 
 

Create_stack.pione（最初の.stackファイル名に1を付加）
<pre>
output '{$I[1][1]}-1.stack'
</pre>
 

Create_fit_each.pione（.3dのための処理） 
<pre>
Rule Create_fit_each
input '*.pad'
input '*-*.stack'
if $Flag_3D
output '{$I[1][1]}.fit-{$I[2][2]}'
output '{$I[1][1]}.3dinfo-{$I[2][2]}'
end
Action
# Create_fit
mrcImageAutoRotationCorrelation -i {$I[1]} -r {$I[2]} -fit {$I[1][1]}.fit-{$I[2][2]} -O {$I[1][1]}.corinfo-{$I[2][2]} \
-n {$N_ROT} -m 18 -nRot1 {$N_ROT1} -nRot2 {$N_ROT2} -nRot3 {$N_ROT3} > /dev/null

# fit_3dinfo
if {$Flag_3D} ; then
awk '/Cor/ { print $18,$16,$2,$3,$4,"0.0"}' {$I[1][1]}.corinfo-{$I[2][2]} | sort -r | sed -e s/pad/fit-{$I[2][2]}/ > {$I[1][1]}.3dinfolst-{$I[2][2]}
head -n 1 {$I[1][1]}.3dinfolst-{$I[2][2]} | awk ' {print $2,$3,$4,$5,$6,$1'} > {$I[1][1]}.3dinfo-{$I[2][2]}
fi

</pre>
 

Create_3d.pione 
<pre>
Rule Create_3d
input '*.3dinfo-{$count}'.all
input '*.fit-{$count}'.all
output '{$filename}-{$count}.3d'
output '{$filename}-{$count}.ds6'
param $filename
param $count
Action
# Sum_3dinfo_3dlst
for info in {$I[1]}
do
cat $info >> {$filename}-{$count}.3dlst
done

# Reconstruct_3dlst_3d
mrc2Dto3D -I {$filename}-{$count}.3dlst -o {$O[1]} -InterpolationMode 2 -Double -DoubleCounter {$filename}-{$count}.3dcounter -CounterThreshold 0.5 -m 1 -WeightMode 6

# Convert_3d_ds6
mrc2map -i {$O[1]} -o {$O[2]} -m 3
End
</pre>

このように実装することで指定した数Repeat_Countに応じた繰り返し処理を行うように機能追加ができます。 
 

=== 応用５（クラスター解析） ===
次は[[クラスター解析]]のMakefileを元にして速度改善を考えてみましょう。[http://sourceforge.jp/projects/eos/scm/git/base/archive/master/Integration/2DClustering/?format=zip こちらのMakefile]を元にしています。今回はMakefileのコマンドも使用します。これにより全体の実装量を削減できますが、makeコマンド実行するときに入出力ファイルがそれぞれ何に当たるのかを注意する必要があります。 
 

==== 前処理 ====
前処理の並列化を考えます。これまでの[[PIONE定義書]]ではeachを使って1ファイル毎の並列処理として実装を行いました。今回はいくつかのグループに分けて、そのグループ毎で並列化を行うようにしてみます。 
 

<pre>
param $task := 2

Rule Main
input '*.roi'.all
input 'Makefile'
input 'Makefile.config'
output '*.pad'.all
Flow
rule Preprocess {filelist:$I[1].all, num:1.upto($task), length:$I[1].length()}
End

Rule Preprocess
input $filelist.nth(((($num-1)*((($length-1)/$task)+1))+1).upto((($num*((($length-1)/$task)+1))|$length).min()))
input 'Makefile'
input 'Makefile.config'
output '*.pad'.all
Action
for data in {$I[1]}
do
make $(basename ${data} ".roi").pad
done
End
</pre>
Preprocess内の処理はMakefile内のコマンドに委ねるようにしています。入力ファイルがかなり複雑となっていますが、これは次のように考えています。 
 

まずパラメータtaskで分割したいグループ数を決め、この数だけルールPreprocessの呼び出すように考えます。 
*filelistにはファイル自体でなく、ファイル名の一覧を送る
*numには分割数の内の何番目かを送る
*lengthにはファイル名の要素数を送る
次にPreprocess側では受け取ったパラメータからグループ毎で使用するファイル名を決め、それらを入力ファイルとすることで分割を実現します。なお、今回使用しているupto, length, minなどのメソッドについては[[PIONEの式]]を参照して下さい。 
 

次のグラフは上記の前処理を256, 512, 1024, 2048, 4096(pixel)の画像ファイル100枚を入力としてタスク数1, 2, 4, 10で動作したときの処理時間です。 
[[画像:Outdata-PIONE-Advanced5-1.png]] 
allは（前処理に関する）全体の処理、processは前処理自体、otherはそれ以外のファイル通信などの処理時間を表しています。 
 

ここでタスク数を増やしたときの変化に注目します。全体の処理時間についてt=1（シングルタスク）との比率は下記のようになりました。 
[[画像:Outdata-PIONE-Advanced5-2.png]] 
2048サイズまでは処理時間が短くなっています。今回はタスク数を増やしても速度の改善は見られません。タスク数を増やすことによって前処理自体の時間は軽減されますが、それ以外のファイル通信など処理で逆に時間がかかってしまうためです。 
 

<table>
<tr>
<td>[[画像:Outdata-PIONE-Advanced5-5.png]]</td>
<td>[[画像:Outdata-PIONE-Advanced5-6.png]]</td>
</tr>
<tr>
<td>前処理はタスク数が多い方が速くなる（このマシンではt=4まで）</td>
<td>タスク数が多くなると並列処理の準備（ファイル通信など）は時間がかかる。</td>
</tr>
<table>
 

==== クラスター解析による分類 ====
本処理のクラスター解析による分類の速度改善を考えてみましょう。Makefileでは[[mrcImageClusterAnalysis]]によって画像毎の相関リストを作って近い画像同士を分類して、グループを作り、それぞれのグループによって平均画像を作成しています。今回はこのグループ毎の平均画像に対してリファインメントを行う部分にて並列化を行ってみます。 
 

===== グループ分け =====
まず、全ての.padファイルを入力としてmakeコマンドによってクラスター解析による分類を行います。すると、分類された.padファイルの一覧all.padsortlstと樹形図all.treeinfoが出力されるので、この2つのファイルを指定した分割数divideだけ分割してそれぞれ.lst .treeファイルを作成します。また、最初のmakeコマンドによって1回目の平均画像が得られますので、この画像がどのグループに属するのか番号付けして出力しています。（ルートに近く分割できない画像は0として番号付けする）下記はその実装例です。 
 

<pre>
Rule Process
input '*.pad'.all
input 'Makefile'
input 'Makefile.config'
output 'all.padsortlst'
output 'all.treeinfo'
output ((1.upto($divide).str())+".lst").d().all()
output ((1.upto($divide).str())+".tree").d().all()
output ("*.pad"+(1.upto($divide).str())).d().all()
output ("*.avg"+(0.upto($divide).str())).d().all()
output '*.avglst'.all
Action
ls -1 *.pad > all.padlst
make Log
make LogPS

cp {$O[1]} 1.lst
cp {$O[2]} 1.tree
for (( i=2; i<={$divide}; i++ ))
do
max=0
for data in $(ls *.lst)
do
num=$(wc -l ${data} | awk '{printf $1}')
if [ ${num} -gt ${max} ] ; then
max=${num}
maxlist="${data}"
fi
done
maxtree="$(basename ${maxlist} '.lst').tree"
root=$(head -1 ${maxtree} | awk '{printf("%d", $1)}')
rootname=$(basename $(awk -v val=${root} '$2==val {printf("%s", $1)}' ${maxlist}) ".pad")
cp ${maxlist} ${rootname}.avglst
cp ${rootname}.pad.avg ${rootname}.pad.avg0
maxpos=$(awk -v val=${root} '$2==val {printf("%f", $3)}' ${maxlist})
line=$(awk -v val=${root} '$2==val {print NR}' ${maxlist})
head -$((${line} - 1)) ${maxlist} > ${i}.lst
tail -$(($(wc -l ${maxlist} | awk '{print $1}') - ${line} + 1)) ${maxlist} > tmp
cp tmp ${maxlist}

max_t=$(wc -l ${maxtree} | awk '{printf $1}')
max_l=$(wc -l ${maxlist} | awk '{printf $1}')
line_t=$(awk -v val=${root} '$1==val {print NR}' ${maxtree})
head -$((${max_l} + ${line_t} - 1)) ${maxtree} | tail -$((${max_l} - 1)) > tmp
tail -$((${max_t} - ${max_l})) ${maxtree} > ${i}.tree
cp tmp ${maxtree}
done

for (( i=1; i<={$divide}; i++ ))
do
for data in $(awk '{print $1}' ${i}.lst)
do
cp ${data} ${data}${i}
cp ${data}.avg ${data}.avg${i}
done
done
End
</pre>
.lst .treeファイルが最大のものから２分割するようにし、分割する前の.lstファイルを.avglstとしてグループ0の平均画像のデータとして取り扱うようにしています。 
 

===== グループ毎の平均画像のリファインメント =====
グループ分けされた平均画像についてのリファインメントを行います。まず、.lst .treeファイルから平均画像を構成している画像リスト.avglstファイルを作成します。そして、そのリストを使用してリファインメントを行います。このとき、[[mrcImageAutoRotationCorrelation]]と[[mrcImageAverage]]を使用していますが、設定内容をMakefileと同じにするためにMakefile.configから特定のパラメータを読み取るようにしています。 
 

<pre>
Rule Refinement
input '*.pad{$num}'.all
input '*.avg{$num}'.all
input '{$num}.lst'
input '{$num}.tree'
input 'Makefile.config'
output ($I[1][1].str()+".pad.avg").d().all()
output ($I[1][1].str()+".pad.avg.tiff").d().all()
output ($I[1][1].str()+".pad.avg"+$num.str()+".tiff").d().all()
Action
max=$(wc -l {$num}.tree | awk '{printf $1}')
data=$(head -1 {$num}.tree)
i=$(echo ${data} | awk '{print $1}')
name=$(basename $(awk -v i=${i} '$2==i {print $1}' {$num}.lst) ".pad")
cp {$num}.lst ${name}.avglst
cp {$num}.tree ${name}.tree

for (( k=1; k<=max ; k++ ))
do
i=$(head -${k} {$num}.tree | tail -1 | awk '{print $1}')
name=$(basename $(awk -v i=${i} '$2==i {print $1}' {$num}.lst) ".pad")

if [ $(wc -l ${name}.avglst | awk '{print $1}') -gt 2 ] ; then
tpos=$(awk -v i=${i} '$2==i {print NR}' ${name}.avglst)
tline=$(wc -l ${name}.avglst | awk '{print $1}')

head -$((${tline} - ${tpos} + 1)) ${name}.tree | tail -$((${tline} - ${tpos})) > tmp
i_sub1=$(head -1 tmp | tail -1 | awk '{print $1}')
name_sub1=$(basename $(awk -v i=${i_sub1} '$2==i {print $1}' ${name}.avglst) ".pad")
if [ $(wc -l tmp | awk '{print $1}') -ne 0 ] ; then
cp tmp ${name_sub1}.tree
tail -$((${tline} - ${tpos} + 1)) ${name}.avglst > ${name_sub1}.avglst
fi

tail -$((${tpos} - 2)) ${name}.tree > tmp
i_sub2=$(head -1 tmp | awk '{print $1}')
name_sub2=$(basename $(awk -v i=${i_sub2} '$2==i {print $1}' ${name}.avglst) ".pad")
if [ $(wc -l tmp | awk '{print $1}') -ne 0 ] ; then
cp tmp ${name_sub2}.tree
head -$((${tpos} - 1)) ${name}.avglst > ${name_sub2}.avglst
fi
fi
done

cat Makefile.config | sed -e s/'='/' '/ > Makefile.config.tmp
ClusterCorrelationMode=$(awk '$1=="ClusterCorrelationMode" {print $2}' Makefile.config.tmp)
ClusterRotationRangeMin=$(awk '$1=="ClusterRotationRangeMin" {print $2}' Makefile.config.tmp)
ClusterRotationRangeMax=$(awk '$1=="ClusterRotationRangeMax" {print $2}' Makefile.config.tmp)
ClusterRotationRangePartitionNumber=$(awk '$1=="ClusterRotationRangePartitionNumber" {print $2}' Makefile.config.tmp)
ClusterRotationIterationNumber=$(awk '$1=="ClusterRotationIterationNumber" {print $2}' Makefile.config.tmp)

for data in $(ls *.avglst)
do
name=$(basename ${data} ".avglst")
awk '{print $1}' ${data} | sed -e s/.pad/.pad.fit/ > ${name}.fitlst
cp ${name}.pad.avg{$num} ${name}.pad.avg
for (( i=0; i < {$refine}; i++ ))
do
for element in $(awk '{print $1}' ${data})
do
mrcImageAutoRotationCorrelation -i ${element}{$num} -r ${name}.pad.avg -fit ${element}.fit -cor ${element}.cor \
-Method ${ClusterRotationCorrelationMode} -m ${ClusterCorrelationMode} -Iter ${ClusterRotationIterationNumber} \
-range ${ClusterRotationRangeMin} ${ClusterRotationRangeMax} -n ${ClusterRotationRangePartitionNumber}
done

mrcImageAverage -i ${name}.fitlst -o ${name}.pad.avg
done
mrc2tiff -i ${name}.pad.avg -o ${name}.pad.avg.tiff
mrc2tiff -i ${name}.pad.avg{$num} -o ${name}.pad.avg{$num}.tiff
done
End
</pre>
 

===== ルートに近い平均画像のリファインメント =====
ルートに近く、分割できない平均画像についてもリファインメントを行います。ルールRefinementとほとんど同じですが、平均画像を構成している画像リストはすでにルールProcessで作成されているので、本処理のみで十分です。 
 

<pre>
Rule RefinementRoot
input '*.pad'.all
input '*.pad.avg0'.all
input ($I[2][1].str()+".avglst").d().all()
input 'Makefile.config'
output ($I[1][1].str()+".pad.avg").d().all()
output ($I[1][1].str()+".pad.avg.tiff").d().all()
output ($I[1][1].str()+".pad.avg0.tiff").d().all()
Action
cat Makefile.config | sed -e s/'='/' '/ > Makefile.config.tmp
ClusterCorrelationMode=$(awk '$1=="ClusterCorrelationMode" {print $2}' Makefile.config.tmp)
ClusterRotationRangeMin=$(awk '$1=="ClusterRotationRangeMin" {print $2}' Makefile.config.tmp)
ClusterRotationRangeMax=$(awk '$1=="ClusterRotationRangeMax" {print $2}' Makefile.config.tmp)
ClusterRotationRangePartitionNumber=$(awk '$1=="ClusterRotationRangePartitionNumber" {print $2}' Makefile.config.tmp)
ClusterRotationIterationNumber=$(awk '$1=="ClusterRotationIterationNumber" {print $2}' Makefile.config.tmp)
ClusterRotationCorrelationMode=$(awk '$1=="ClusterRotationCorrelationMode" {print $2}' Makefile.config.tmp)

for data in $(ls *.avglst)
do
name=$(basename ${data} ".avglst")
awk '{print $1}' ${data} | sed -e s/.pad/.pad.fit/ > ${name}.fitlst
cp ${name}.pad.avg0 ${name}.pad.avg
for (( i=0; i < {$refine}; i++ ))
do
for element in $(awk '{print $1}' ${data})
do
mrcImageAutoRotationCorrelation -i ${element} -r ${name}.pad.avg -fit ${element}.fit -cor ${element}.cor \
-Method ${ClusterRotationCorrelationMode} -m ${ClusterCorrelationMode} -Iter ${ClusterRotationIterationNumber} \
-range ${ClusterRotationRangeMin} ${ClusterRotationRangeMax} -n ${ClusterRotationRangePartitionNumber}
done

mrcImageAverage -i ${name}.fitlst -o ${name}.pad.avg
done
mrc2tiff -i ${name}.pad.avg -o ${name}.pad.avg.tiff
mrc2tiff -i ${name}.pad.avg0 -o ${name}.pad.avg0.tiff
done
End
</pre>
 

===== 動作検証 =====
では実行してみましょう。 
今回は入力画像を32×32(Pixel)を54枚用意しリファインメントを5回として、-t毎の実行時間を検証してみます。画像は全処理のログで、今回の実装部分はRefinement（ログの２分辺り）からです。（入力画像は同ディレクトリ内のMain_ROIr.pioneで作成しました） 
 

t=1（5分強） 
[[画像:Outdata-PIONE-Advanced5-t1.png]] 
 

t=2（4分程度） 
[[画像:Outdata-PIONE-Advanced5-t2.png|730px]] 
 

t=4（3分強） 
[[画像:Outdata-PIONE-Advanced5-t4.png|670px]] 
 

タスク数を増やす毎に処理時間の短縮（本処理が半分以下に軽減）が実現できています。今回の検証では入力画像の枚数が少ないので、ファイル通信があまりなく本処理の時間にほぼ直接影響されるため並列処理の効果が得られました。 
 

==== Makefile内のパラメータ設定 ====
今回は処理の一部をMakefileの処理に委ねていますが、使用するパラメータはMakefile.configに設定するようになっています。パラメータ管理をまとめて行えるようにこの部分のパラメータもPIONEで設定できるようにしてみましょう。 
 

元のMakefile.configは下記のようになっています。 
<pre>
# Makefile.config for 2D Clustering

# Cluster Name
CLUSTER=all

# Pad Parameter
# Width(Nx) before shrinking
PADWIDTH=32
# Height(Ny) before shrinking
PADHEIGHT=32
# Shrink for Speed Up in clustering
SHRINK=1
# Pad Mode
PADMODE=13
# LOWPASS
LowPassMode=4
LowPassResolution=0.1

# Clustering
ClusterCorrelationMode=19
#
ClusterRotationRangeMin=0
ClusterRotationRangeMax=360
ClusterRotationRangePartitionNumber=72
ClusterRotationIterationNumber=2
ClusterRotationCorrelationMode=0
#
ClusterMode=2

# ClusterShow
TreeRootPositionX=0
TreeRootPositionY=400
TreeScaleX=10
TreeScaleY=100
TreeOffset=1e1
</pre>
今回はPIONEで設定したパラメータから上記のようなMakefile.configを作成することで各種パラメータの管理を全てPIONE定義書内で行えるようにします。 
 

Main.pione内に下記の内容を追加します。 
<pre>
# Cluster Name
param $CLUSTER := "all"

# Pad Parameter
# Width(Nx) before shrinking
param $PADWIDTH := 32
# Height(Ny) before shrinking
param $PADHEIGHT := 32
# Shrink for Speed Up in clustering
param $SHRINK := 1
# Pad Mode
param $PADMODE := 13
# LOWPASS
param $LowPassMode := 4
param $LowPassResolution := 0.1

# Clustering
param $ClusterCorrelationMode := 19
#
param $ClusterRotationRangeMin := 0
param $ClusterRotationRangeMax := 360
param $ClusterRotationRangePartitionNumber := 72
param $ClusterRotationIterationNumber := 2
param $ClusterRotationCorrelationMode := 0
#
param $ClusterMode := 2

# ClusterShow
param $TreeRootPositionX := 0
param $TreeRootPositionY := 400
param $TreeScaleX := 10
param $TreeScaleY := 100
param $TreeOffset := "1e1"

# Sequence with Keys(Makefile.config for 2D Clustering)
$Config := ("CLUSTER":$CLUSTER) |
("PADWIDTH":$PADWIDTH) |
("PADHEIGHT":$PADHEIGHT) |
("SHRINK":$SHRINK) |
("PADMODE":$PADMODE) |
("LowPassMode":$LowPassMode) |
("LowPassResolution":$LowPassResolution) |
("ClusterCorrelationMode":$ClusterCorrelationMode) |
("ClusterRotationRangeMin":$ClusterRotationRangeMin) |
("ClusterRotationRangeMax":$ClusterRotationRangeMax) |
("ClusterRotationRangePartitionNumber":$ClusterRotationRangePartitionNumber) |
("ClusterRotationIterationNumber":$ClusterRotationIterationNumber) |
("ClusterRotationCorrelationMode":$ClusterRotationCorrelationMode) |
("ClusterMode":$ClusterMode) |
("TreeRootPositionX":$TreeRootPositionX) |
("TreeRootPositionY":$TreeRootPositionY) |
("TreeScaleX":$TreeScaleX) |
("TreeScaleY":$TreeScaleY) |
("TreeOffset":$TreeOffset)
</pre>
パラメータを設定しています。$TreeOffset := "1e1"のようにeを使用するような数値はPIONEの記法にはありませんので、" "で囲んで一旦文字列として設定しておきます。また、Makefile.configに書き出す処理を簡潔にするために設定したパラメータをキー付きシーケンスとして$Configに登録しています。新たにパラメータを追加したときは$Configにも追加するようにすれば後述で作成されるMakefile.configにも追加されるようになります。Configに値を直接登録することもできますが、実行ユーザが[[pione-client#オプション --params]]を利用してパラメータ設定できるようにparamで定義してから登録しています。 
 

では、Makefile.config作成用のルールを作成して、Mainに追加します。 
<pre>
Rule SetParam
output 'Makefile.config'
Action
key=({$Config.keys})
value=({$Config.values})
for (( i=0; i<{$Config.length}; i++ ))
do
echo "${key[${i}]}=${value[${i}]}" >> {$O[1]}
done
End
</pre>
それぞれのパラメータをキー付きシーケンスとしてConfigに登録しているので、[[PIONEの式#キー付きシーケンス]]のメソッドkeysとvaluesを利用してパラメータ名と値を得ることができますので、Makefile.configに書き込むことができます。 
 

SetParamで作成したMakefile.config
<pre>
CLUSTER=all
PADWIDTH=32
PADHEIGHT=32
SHRINK=1
PADMODE=13
LowPassMode=4
LowPassResolution=0.1
ClusterCorrelationMode=19
ClusterRotationRangeMin=0
ClusterRotationRangeMax=360
ClusterRotationRangePartitionNumber=72
ClusterRotationIterationNumber=2
ClusterRotationCorrelationMode=0
ClusterMode=2
TreeRootPositionX=0
TreeRootPositionY=400
TreeScaleX=10
TreeScaleY=100
TreeOffset=1e1
</pre>
元のMakefile.configと同様のファイルを作成することができました。 
 

==== 分類の点数付け ====
[[単粒子解析#クラスター解析]]で行った分類されたグループと元のモデルとの一致数を算出する処理を追加してみましょう。 
<pre>
# For GroupingPoint
param $filename := "121p-shift2"
param $ROT2 := (0.upto(3)) * 45

Rule GroupingPoint
input '*.lst'.all
input '*.tree'.all
output '{$CLUSTER}.groupinfo'
Action
array_rot2=( {$ROT2} )

total=0
element_total=0
for num in {$I[1][1]}
do
element_num=$(wc -l ${num}.lst | awk '{print $1}')
element_total=$(( ${element_total} + ${element_num} ))
data=$(head -1 ${num}.tree)
root_i=$(echo ${data} | awk '{print $1}')
root_name=$(basename $(awk -v i=${root_i} '$2==i {print $1}' ${num}.lst) ".pad")

max=0
max_i=0
i=0
include_max_rot2=${array_rot2[0]}
for rot2 in ${array_rot2[@]}
do
include_num=$(grep "{$filename}-0-${rot2}-" ${num}.lst | wc -l | awk '{print $1}')
if [ ${include_num} -gt ${max} ] ; then
max=${include_num}
include_max_rot2=${rot2}
max_i=${i}
fi
i=$(( ${i} + 1 ))
done

echo "group${root_i}: match: ${max} owner: ${include_max_rot2}" >> {$O[1]}
total=$(( ${total} + ${max} ))

unset array_rot2[${max_i}]
array_rot2=("${array_rot2[@]}")
done
echo " total: ${total}" >> {$O[1]}
echo "${total} ${element_total}" | awk '{printf("parcentage: %f\n", $1 / $2)}' >> {$O[1]}
End
</pre>
今回、入力する使用ファイルはモデル有りで作成したサンプル画像のみを対象としています。（実際の[[電子顕微鏡]][[画像]]での分類の評価はもっと複雑で、手法としては[[クラスター解析]]や[[単粒子解析#クラスター解析]]で議論する内容）ファイル名がAAAA-0-Y-Z-S.roiのような画像（同ディレクトリMain_ROI.pioneで作成される）でYの回転の違いのみでグループ分けされることを前提として、モデルとの一致数を.groupファイルに出力します。上記のパラメータでは各グループをY回転0°, 45°, 90°, 135°の内、最も一致するグループに当てはめて、その一致数と割合を下記のように出力します。 
 

<pre>
group000022: match: 9 owner: 45
group000013: match: 8 owner: 135
group000028: match: 0 owner: 0
group000001: match: 8 owner: 90
total: 25
parcentage: 0.625000
</pre>
group0000NNのNNはグループ分けされたルートのNo.、owenerは最も一致した角度、matchは一致数をそれぞれ表します。またtotalは一致数の合計、percentageは割合です。 
 

今回はYの回転のみで分類を評価していますが、パラメータやfor文、ログの記述部分などを追加することで、Xの回転も組み合わせて分類することは可能です。また、パラメータROT2は(0.upto(3)) * 45のように等間隔で角度を与えていますが、|で繋いで直接記述することでMain_ROIr.pioneで作成した画像のように等間隔でないファイルについても同様に評価することができます。 
 
<pre>
param $ROT2 := (17.888783 | 114.250336 | 173.771591 | 273.340057)
</pre>

PIONEチュートリアル

2016-04-20T07:04:50Z

Takahiro: /* 基本１１（ループ文２） */

'''PIONE'''チュートリアル 
　ここでは、[[PIONE]]のチュートリアルを行います。始める前に[[PIONEのインストール]]をしておきましょう。

== 基本 ==
=== 基本１（特定のファイルを出力する） ===

　まず、PIONEを動かすにはルール定義書をつくる必要があります。 
どんな言語でも最初に作成するHelloプログラムを作ってみましょう。

　次の内容のファイル'HelloWorld.pione'を作成してみましょう。

Rule Main
output 'message.txt'

Action
echo "Hello PIONE world !" > message.txt
End

このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic1 こちら]からダウンロードできます。 
この後、[[pione-client]]を実行します。

$ pione-client HelloWorld.pione -b helloOutput

例えば、次のような出力が流れます。

==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{})
==> &Anonymous:Main([],{})
SH ------------------------------------------------------------
SH echo "Hello PIONE world !" > message.txt
SH ------------------------------------------------------------
<== &Anonymous:Main([],{})
<-- Distribution: &Anonymous:Root([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})

その結果、helloOutputというディレクトリができます。その中に指定したファイルmessage.txtが出力されています。

$ cat helloOutput/output/message.txt

Hello PIONE world !

もう一度、実行すると今度は、実行の必要がないために次のようなものが出力されます。

==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})

さっきと比べると、Main Ruleが動いていないことが分かります。 
　さて、改めて設定したファイルを眺めてみます。 
まず、最初に呼び出されるルール（Main)が定義されています。

Rule Main

Mainは、Ｃ言語などと同様に特別な意味をもつルールです。 
次に、出力ファイルが定義されています。

output 'message.txt'

ここに書かれたファイルが最終的に-bで指定されたディレクトリに出力として戻ってきます。 
Action以降が実際に起動するプログラムになります。

Action
echo "Hello PIONE world !" > message.txt

実際にはシェルスクリプトが動きますので、どんなものも実行が可能です。

#!/bin/csh

で始めれば、cshを使って記述することもできますし、スクリプト系の言語であれば自由に記述し、実行形式を実行出来ます。 
最後に、RuleをEndで終了します。

End

これが、一番シンプルなルールの書き方です。入力ファイルがないので、出力ファイルがなければ作成し、あれば作成しないという動作をします。 
必要以上の動作をしないところが通常のシェルスクリプトを実行する場合と異なる点です。

=== 基本２（特定のファイルを入力し、出力する（更新判定）） ===

　次に、入力ファイルから出力ファイルを作成する場合の定義書について作成してみましょう。

#Multiplying.pione

Rule Main
input 'test.in'
output 'test.out'

Action
awk '{ print $1*2 }' {$I[1]} > {$O[1]}
End

このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic2 こちら]からダウンロードできます。 
今回は、test.inという入力ファイルの中にある行頭の数字を２倍して、test.outというファイルを作り出すルールです (awkの使い方については、別途勉強してみて下さい)。 
入力ファイルの更新判定により、ルールを実行するかどうかが変わってきます。

　まず、

$ mkdir MultiplyingInput
$ pione-client Multiplying.pione -b MultiplyingOutput -i MultiplyingInput/

として、入力ファイルがあるディレクトリ（指定しなければ、現在のディレクトリ）を指定して実行してみます。

==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})

入力ファイルがありませんので、何もする事がないとして終了してしまいます。先ほどとの違いに気がついたでしょうか。

　次に、ファイルを作成して、実行してみます。

$ echo "3" > MultiplyingInput/test.in
$ echo "5" >> MultiplyingInput/test.in
$ cat MultiplyingInput/test.in
3
5
$ pione-client Multiplying.pione -b MultiplyingOutput -i MultiplyingInput/
==> &Anonymous:Root([test.in],{})
--> Rule Application: &Anonymous:Root([test.in],{})
--> Distribution: &Anonymous:Root([test.in],{})
>>> &Anonymous:Main([test.in],{})
==> &Anonymous:Main([test.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<-- Distribution: &Anonymous:Root([test.in],{})
<-- Rule Application: &Anonymous:Root([test.in],{})
<== &Anonymous:Main([test.in],{})
<== &Anonymous:Root([test.in],{})

$ cat MultiplyingOutput/output/test.out
6
10

となり、確かに２倍の値のファイルができあがっていることが分かります。 
もう一度、実行すると、

$ pione-client Multiplying.pione -b MultiplyingOutput -i MultiplyingInput/
==> &Anonymous:Root([test.in],{})
--> Rule Application: &Anonymous:Root([test.in],{})
<-- Rule Application: &Anonymous:Root([test.in],{})
<== &Anonymous:Root([test.in],{})

となり、ここでも何も実行しません。 
つまり、入力ファイルに比べて出力ファイルのほうが新しいので、更新判定の結果、実行しなくてよいと判断したことになります。賢いですね。

　ここで、ファイルを更新してみましょう。３行目に7を付け加えます。

$ echo "7" >> MultiplyingInput/test.in

そして、実行してみましょう。

$ pione-client Multiplying.pione -b MultiplyingOutput -i MultiplyingInput/
==> &Anonymous:Root([test.in],{})
--> Rule Application: &Anonymous:Root([test.in],{})
--> Distribution: &Anonymous:Root([test.in],{})
>>> &Anonymous:Main([test.in],{})
==> &Anonymous:Main([test.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<-- Distribution: &Anonymous:Root([test.in],{})
<== &Anonymous:Main([test.in],{})
<-- Rule Application: &Anonymous:Root([test.in],{})
<== &Anonymous:Root([test.in],{})

$ cat MultiplyingOutput/output/test.out
6
10
14

今度は実行されました。これが更新判定によりルールが実行されるかどうかが判定されているということです。 
もう一度実行しても、今度は実行されません。

$ pione-client Multiplying.pione -b MultiplyingOutput -i MultiplyingInput/
==> &Anonymous:Root([test.in],{})
--> Rule Application: &Anonymous:Root([test.in],{})
<-- Rule Application: &Anonymous:Root([test.in],{})
<== &Anonymous:Root([test.in],{})

さて、出力ファイルを削除してみるとどうなるでしょうか。

$ rm MultiplyingOutput/output/test.out

今度は、実行されますね。

　では、内容は変えずに、touch コマンドを使って、入力ファイルの修正時刻を変えるとどうなるでしょうか。

$ touch MultiplyingInput/test.in

今回も、予想通り、動作しました。 
もし、動作しないようだったら、バグです。すぐに、[https://github.com/pione GITHUB/PIONE]に報告しましょう。 
この基本２が理解できれば、まず、PIONEの動きの基本が理解できたことになります。

　ところで、Actionで定義した動作の中に、見慣れない記号（ {$I[1]}, {$O[1]} ）が現れています。

Action
awk '{ print $1*2 }' {$I[1]} > {$O[1]}
End

{$I[1]}は入力ファイル、{$O[1]}は出力ファイルを表しています。それぞれの[]の中の数字１は、input/outputで定義したそれぞれの１番目ということを意味しています。 
次の基本３での複数ファイルの入出力では１以外が使われることになります。 
まだ、何が便利か少し分かりづらいと思いますが、例えば、Multiplying2.pioneとして、次のように記述するとどのように動作するでしょうか。

Rule Main
input 'test.in'
output '{$I[1]}.out'

Action
awk '{ print $1*2 }' {$I[1]} > {$O[1]}
End

少し考えてみて下さい。そして、動作させてみましょう。

$ pione-client Multiplying2.pione -b MultiplyingOutput -i MultiplyingInput/

MultiplyingOutput/outputのディレクトリにはどんなファイルができあがったでしょうか。 
そうですね。test.in.outができあがっています。何故かを考えてみましょう。

=== 基本３（複数ファイルの入力と複数ファイルの出力）===

　さて、更新判定が理解できたところで、複数ファイルの入出力について考えてみましょう。 
test1.in, test2.inから、それぞれ２倍した数が格納された、test1.out, test2.outが出力できる[[PIONE定義書]]を作成してみましょう。 
ここで、名前をMultiplyingFiles.pioneとして作成してみましょう。
-----

　問題１：上記のMultiplyingFiles.pioneを作成して実行してみて下さい。

-----

　解答例１：

Rule Main
input 'test1.in'
input 'test2.in'
output 'test1.out'
output 'test2.out'

Action
awk '{ print $1*2 }' {$I[1]} > {$O[1]}
awk '{ print $1*2 }' {$I[2]} > {$O[2]}
End

-----

このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic3 こちら]からダウンロードできます。 
どうでしょうか。思ったように動きましたか。複数のファイルがあれば、複数書き並べればよいのです。

　でもなんだか、同じ事をするのに、同じような行を何行も書くのは嫌だなと思いませんか。もし、２倍を５倍に変えたくなったら全ての行を書き換えなくてはなりません。 
１０行ぐらいならそれでもよいけれど、１００個、１０００個とファイルが増えてきたらどうでしょうか。だんだん嫌になってきませんか。 

　では、どうすれば良いでしょうか。例えば、シェルスクリプトが得意なひとは次の様なプログラムを設定することも出来ます。

-----

　解答例２：

Rule Main
input 'test1.in'
input 'test2.in'
output 'test1.out'
output 'test2.out'

Action
for i in `ls *.in`; do
awk '{ print $1*2 }' $i > `basename $i .in`.out
done
End

-----

これでも、ファイルが増えるたびにinput/outputを書き換える必要があります。 
そこで、全てのファイルを入力し、全てのファイルを出力するように入出力を表現することも出来ます。

-----

　解答例３：

Rule Main
input '*.in'.all
output '*.out'.all

Action
for i in `ls *.in`; do
awk '{ print $1*2 }' $i > `basename $i .in`.out
done
End

-----

どうでしょうか。うまく動作したでしょうか。ここで、

input '*.in'.all
output '*.out'.all

の部分は、*は任意の文字列を表現します。つまり、*.inは、ファイルの最後が.inで終了しているファイル全て、*.outは、ファイルの最後が.outで終了しているファイル全てを表します。 
.allがついていると、全てのファイルを取り扱うことを意味しています。 
.allが付いていないときには、.eachがついていることがdefaultとして決まっています。一つひとつのファイルを別々に実行するという意味になります。 
これでずいぶんと記述しやすくなりました。

　でも、これだと、*.inのどれかのファイルが更新されていると全て変更になってしまいます。試してみて下さい。なんだか無駄ですね。 
また、同時にできるはずのことをfor文を使って順次実行しているので、時間も無駄ですね。このくらいのタスクであれば、たいして時間がかかるわけではないのですが、もっと時間のかかるタスクだったらどうでしょうか。 
必要なファイルの更新だけを、できれば複数のホストや一台でもマルチコアＣＰＵを使って、同時に動かすともっと早く終了できるようになるはずです。

　さて、それではどのようにすればよいのでしょうか。それが次の基本４になります。だんだんPIONEらしくなってきます。

=== 基本４（複数ファイルの入力と複数ファイルの出力の並列処理）===

　次は、さっきと違ってallが付いていません。なにが起きるかを考えてみましょう。

Rule Main
input '*.in'
output '{$I[1][1]}.out'
Action
awk '{ print $1*2 }' {$I[1]} > {$O[1]}
End

このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic4 こちら]からダウンロードできます。 
ここで、{$I[1][1]}.outは1番目のinputで拡張子を除いたファイル名を指します。（参照: [[PIONE定義書#入力定義]]） 
下は実行した例です。

$ pione-client MultiplyingFilesEach.pione -b MultiplyingFilesEachOutput -i MultiplyingFilesInput/ -t 4
==> &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
>>> &Anonymous:Main([test1.in],{})
>>> &Anonymous:Main([test2.in],{})
>>> &Anonymous:Main([test3.in],{})
>>> &Anonymous:Main([test4.in],{})
>>> &Anonymous:Main([test5.in],{})
>>> &Anonymous:Main([test6.in],{})
>>> &Anonymous:Main([test7.in],{})
==> &Anonymous:Main([test1.in],{})
==> &Anonymous:Main([test2.in],{})
==> &Anonymous:Main([test3.in],{})
==> &Anonymous:Main([test4.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Main([test2.in],{})
<== &Anonymous:Main([test1.in],{})
<== &Anonymous:Main([test3.in],{})
<== &Anonymous:Main([test4.in],{})
==> &Anonymous:Main([test5.in],{})
==> &Anonymous:Main([test6.in],{})
==> &Anonymous:Main([test7.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Main([test6.in],{})
<== &Anonymous:Main([test5.in],{})
<== &Anonymous:Main([test7.in],{})
<-- Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<-- Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Root([test1.in,test2.in,test3.in,...],{})

４つのタスクが並列に動いている様子が分かるでしょうか。 
確かに４つずつのタスク( ==> &Anonymous:Main([testN.in],{}))が並列に動作しているようです。 
もう一度実行してみると下のようになります。

$ pione-client MultiplyingFilesEach.pione -b MultiplyingFilesEachOutput -i MultiplyingFilesInput/ -t 4
==> &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<-- Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Root([test1.in,test2.in,test3.in,...],{})

今度は実行されません。そこで、ひとつファイルを更新してみます。

$ touch MultiplyingFilesInput/test3.in
$ pione-client MultiplyingFilesEach.pione -b MultiplyingFilesEachOutput -i MultiplyingFilesInput/ -t 4
==> &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
>>> &Anonymous:Main([test3.in],{})
==> &Anonymous:Main([test3.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Main([test3.in],{})
<-- Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<-- Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Root([test1.in,test2.in,test3.in,...],{})

となり、test3.inだけが更新されているのが分かります。これがeachとしての振る舞いです。 

====[[基本４の補足（eachでの速度検証）]]====
eachを使った並列化処理による計算速度向上の一例を示しています。 

=== 基本５（直列：フロールールの設定）===

　さて、もう少し複雑なルールについて設定してみましょう。 
まず、ふたつのルールを組み合わせて、並列計算することを考えてみます。

Rule Main
input '*.in'
output '*.out'
Flow
rule First
rule Second
End

Rule First
input '*.in'
output '{$I[1][1]}.route'
Action
awk '{ print $1*2 }' {$I[1]} > {$O[1]}
End

Rule Second
input '*.route'
output '{$I[1][1]}.out'
Action
awk '{ print $1+1 }' {$I[1]} > {$O[1]}
End

このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic5 こちら]からダウンロードできます。

　実行結果を以下に示します。最初に５つのタスク(First)が並列で動いているのがわかります。 
その後、終了した順に、次のルールが動いています。

$ pione-client Serial2.pione -i SerialInput/ -b Serial2Output
==> &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
>>> &Anonymous:Main([test1.in],{})
>>> &Anonymous:Main([test2.in],{})
>>> &Anonymous:Main([test3.in],{})
>>> &Anonymous:Main([test4.in],{})
>>> &Anonymous:Main([test5.in],{})
==> &Anonymous:Main([test1.in],{})
--> Rule Application: &Anonymous:Main([test1.in],{})
--> Distribution: &Anonymous:Main([test1.in],{})
>>> &Anonymous:First([test1.in],{})
==> &Anonymous:Main([test2.in],{})
--> Rule Application: &Anonymous:Main([test2.in],{})
--> Distribution: &Anonymous:Main([test2.in],{})
>>> &Anonymous:First([test2.in],{})
==> &Anonymous:Main([test3.in],{})
--> Rule Application: &Anonymous:Main([test3.in],{})
--> Distribution: &Anonymous:Main([test3.in],{})
>>> &Anonymous:First([test3.in],{})
==> &Anonymous:Main([test4.in],{})
--> Rule Application: &Anonymous:Main([test4.in],{})
--> Distribution: &Anonymous:Main([test4.in],{})
>>> &Anonymous:First([test4.in],{})
==> &Anonymous:Main([test5.in],{})
--> Rule Application: &Anonymous:Main([test5.in],{})
--> Distribution: &Anonymous:Main([test5.in],{})
>>> &Anonymous:First([test5.in],{})
==> &Anonymous:First([test1.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:First([test1.in],{})
<-- Distribution: &Anonymous:Main([test1.in],{})
--> Distribution: &Anonymous:Main([test1.in],{})
>>> &Anonymous:Second([test1.route],{})
==> &Anonymous:First([test2.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:First([test2.in],{})
<-- Distribution: &Anonymous:Main([test2.in],{})
--> Distribution: &Anonymous:Main([test2.in],{})
>>> &Anonymous:Second([test2.route],{})
==> &Anonymous:First([test3.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:First([test3.in],{})
<-- Distribution: &Anonymous:Main([test3.in],{})
--> Distribution: &Anonymous:Main([test3.in],{})
>>> &Anonymous:Second([test3.route],{})
==> &Anonymous:First([test4.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:First([test4.in],{})
<-- Distribution: &Anonymous:Main([test4.in],{})
--> Distribution: &Anonymous:Main([test4.in],{})
>>> &Anonymous:Second([test4.route],{})
==> &Anonymous:First([test5.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:First([test5.in],{})
<-- Distribution: &Anonymous:Main([test5.in],{})
--> Distribution: &Anonymous:Main([test5.in],{})
>>> &Anonymous:Second([test5.route],{})
==> &Anonymous:Second([test1.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Second([test1.route],{})
<-- Distribution: &Anonymous:Main([test1.in],{})
<-- Rule Application: &Anonymous:Main([test1.in],{})
<== &Anonymous:Main([test1.in],{})
==> &Anonymous:Second([test2.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Second([test2.route],{})
<-- Distribution: &Anonymous:Main([test2.in],{})
<-- Rule Application: &Anonymous:Main([test2.in],{})
<== &Anonymous:Main([test2.in],{})
==> &Anonymous:Second([test3.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Second([test3.route],{})
<-- Distribution: &Anonymous:Main([test3.in],{})
<-- Rule Application: &Anonymous:Main([test3.in],{})
<== &Anonymous:Main([test3.in],{})
==> &Anonymous:Second([test4.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Second([test4.route],{})
<-- Distribution: &Anonymous:Main([test4.in],{})
<-- Rule Application: &Anonymous:Main([test4.in],{})
<== &Anonymous:Main([test4.in],{})
==> &Anonymous:Second([test5.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' {$I[1]} > {$O[1]}
SH ------------------------------------------------------------
<== &Anonymous:Second([test5.route],{})
<-- Distribution: &Anonymous:Main([test5.in],{})
<-- Rule Application: &Anonymous:Main([test5.in],{})
<-- Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Main([test5.in],{})
<-- Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Root([test1.in,test2.in,test3.in,...],{})

一度、終了しましたので、次は実行されません。

$ pione-client Serial2.pione -i SerialInput/ -b Serial2Output
==> &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<-- Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Root([test1.in,test2.in,test3.in,...],{})

さて、ここで、ファイルをひとつ(test6.in)増やしてみましょう。

$ pione-client Serial2.pione -i SerialInput/ -b Serial2Output
==> &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
--> Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
>>> &Anonymous:Main([test6.in],{})
==> &Anonymous:Main([test6.in],{})
--> Rule Application: &Anonymous:Main([test6.in],{})
--> Distribution: &Anonymous:Main([test6.in],{})
>>> &Anonymous:First([test6.in],{})
==> &Anonymous:First([test6.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' test6.in > test6.route
SH ------------------------------------------------------------
<== &Anonymous:First([test6.in],{})
<-- Distribution: &Anonymous:Main([test6.in],{})
--> Distribution: &Anonymous:Main([test6.in],{})
>>> &Anonymous:Second([test6.route],{})
==> &Anonymous:Second([test6.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' test6.route > test6.out
SH ------------------------------------------------------------
<== &Anonymous:Second([test6.route],{})
<-- Distribution: &Anonymous:Main([test6.in],{})
<-- Rule Application: &Anonymous:Main([test6.in],{})
<-- Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Main([test6.in],{})
--> Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<-- Distribution: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<-- Rule Application: &Anonymous:Root([test1.in,test2.in,test3.in,...],{})
<== &Anonymous:Root([test1.in,test2.in,test3.in,...],{})

新しくできたファイルだけが作られていることがわかります。 
それでは、ファイルの更新がかかったときはどうなるでしょうか。test2.inをtouchコマンドで更新してみました。

$ touch SerialInput/test2.in
$ pione-client Serial2.pione -i SerialInput/ -b Serial2Output2
==> &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
--> Rule Application: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
--> Distribution: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
>>> &Anonymous:Main([test2.in],{})
>>> &Anonymous:Main([test6.in],{})
==> &Anonymous:Main([test2.in],{})
--> Rule Application: &Anonymous:Main([test2.in],{})
--> Distribution: &Anonymous:Main([test2.in],{})
>>> &Anonymous:First([test2.in],{})
==> &Anonymous:Main([test6.in],{})
--> Rule Application: &Anonymous:Main([test6.in],{})
<-- Rule Application: &Anonymous:Main([test6.in],{})
<== &Anonymous:Main([test6.in],{})
==> &Anonymous:First([test2.in],{})
SH ------------------------------------------------------------
SH awk '{ print $1*2 }' test2.in > test2.route
SH ------------------------------------------------------------
<== &Anonymous:First([test2.in],{})
<-- Distribution: &Anonymous:Main([test2.in],{})
--> Distribution: &Anonymous:Main([test2.in],{})
>>> &Anonymous:Second([test2.route],{})
==> &Anonymous:Second([test2.route],{})
SH ------------------------------------------------------------
SH awk '{ print $1+1 }' test2.route > test2.out
SH ------------------------------------------------------------
<== &Anonymous:Second([test2.route],{})
<-- Distribution: &Anonymous:Main([test2.in],{})
<-- Rule Application: &Anonymous:Main([test2.in],{})
<-- Distribution: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
<== &Anonymous:Main([test2.in],{})
--> Distribution: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
>>> &Anonymous:Main([test6.in],{})
==> &Anonymous:Main([test6.in],{})
--> Rule Application: &Anonymous:Main([test6.in],{})
<-- Rule Application: &Anonymous:Main([test6.in],{})
<== &Anonymous:Main([test6.in],{})
<-- Distribution: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
--> Distribution: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
<-- Distribution: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
<-- Rule Application: &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})
<== &Anonymous:Root([.DS_Store,test1.in,test2.in,...],{})

となり、新しいファイルであるtest2.in, test6.inに関しては、変更の可能性があるので起動し始めます。 
しかし、実際にinputファイルが更新されたtest2.inのみ処理が行われ、test2.outのみ作成されます。 

====[[基本５の補足（並列処理での速度向上例）]]====
基本5のプログラムに関して速度向上の例を示しています。 

=== 基本６（パラメータの定義） ===
　入力データは、ファイルから読み取る以外にパラメータとして使用する方法があります。 
パラメータにはbasicとadvancedの２つがあります。処理上の違いは特にありませんが、前者を基本パラメータ、後者を上級者向けパラメータとして定義することで[[ユーザ]]のレベルに応じて変更可能なパラメータを区別することができます。 
下記のように定義します。（参照：[[PIONE定義書#パラメータ定義]]） 

<pre>
param $val := 123
basic param $b_val := 456
advanced param $a_val := 987

Basic Param
$b_val1 := 135
$b_val2 := 246
End

Advanced Param
$a_val1 := 975
$a_val2 := 864
End

Rule Main
output 'message.txt'
param $main_val := $val * 10
Flow
rule Sub {sub_val1: $main_val}
End

Rule Sub
output 'message.txt'
param $sub_val1
param $sub_val2 := $val * 100
Action
echo "Basic Parameters:" > {$O[1]};
echo " val: {$val}" >> {$O[1]};
echo " b_val: {$b_val}" >> {$O[1]};
echo " b_val1: {$b_val1}" >> {$O[1]};
echo " b_val2: {$b_val2}" >> {$O[1]};
echo "Advanced Parameters:" >> {$O[1]};
echo " a_val: {$a_val}" >> {$O[1]};
echo " a_val1: {$a_val1}" >> {$O[1]};
echo " a_val2: {$a_val2}" >> {$O[1]};
echo "Parameters in Sub:" >> {$O[1]};
echo " sub_val1: {$sub_val1}" >> {$O[1]};
echo " sub_val2: {$sub_val2}" >> {$O[1]};
End
</pre>
１つずつ定義するときはそれぞれbasic param XXX、advanced param YYYのように記述します。（単にparam ZZZとしたときはbasic扱いとなります。） 
まとめて定義したいときはBasic Param ~ End, Advanced Param ~ Endで囲みます。 
定義する変数名の先頭には'''$'''を付けて記述し、''':='''にてデフォルト値を定義することができます。 
またAction内で使用するときは入力ファイルや出力ファイルと同様に'''{''' '''}'''で括ります。 

設定したパラメータはオプション--params="{XXX:N}"で値を設定して実行します。 
また、定義書内でデフォルト値を記述しておけば、--params内で設定しなかったパラメータもデフォルト値で処理されます。 

今回はbasicのみに値を設定して実行してみます。 
<pre>
/Basic6$ pione-client ParamEcho.pione -b ParamEcho --params="{val:1,b_val:3,b_val1:5,b_val2:7}"
"{val:1,b_val:3,b_val1:5,b_val2:7}"
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{main_val:(10)})
==> &Anonymous:Main([],{main_val:(10)})
--> Rule Application: &Anonymous:Main([],{main_val:(10)})
--> Distribution: &Anonymous:Main([],{main_val:(10)})
>>> &Anonymous:Sub([],{sub_val1:(10),sub_val2:(100)})
==> &Anonymous:Sub([],{sub_val1:(10),sub_val2:(100)})
SH ------------------------------------------------------------
SH echo "Basic Parameters:" > message.txt;
SH echo " val: 1" >> message.txt;
SH echo " b_val: 3" >> message.txt;
SH echo " b_val1: 5" >> message.txt;
SH echo " b_val2: 7" >> message.txt;
SH echo "Advanced Parameters:" >> message.txt;
SH echo " a_val: 987" >> message.txt;
SH echo " a_val1: 975" >> message.txt;
SH echo " a_val2: 864" >> message.txt;
SH echo "Parameters in Sub:" >> message.txt;
SH echo " sub_val1: 10" >> message.txt;
SH echo " sub_val2: 100" >> message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Sub([],{sub_val1:(10),sub_val2:(100)})
<-- Distribution: &Anonymous:Main([],{main_val:(10)})
<-- Rule Application: &Anonymous:Main([],{main_val:(10)})
<-- Distribution: &Anonymous:Root([],{})
<== &Anonymous:Main([],{main_val:(10)})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
/Basic6$ cat ParamEcho/output/message.txt
Basic Parameters:
val: 1
b_val: 3
b_val1: 5
b_val2: 7
Advanced Parameters:
a_val: 987
a_val1: 975
a_val2: 864
Parameters in Sub:
sub_val1: 10
sub_val2: 100
/Basic6$
</pre>
設定を反映した処理が実行できました。 

==== パラメータのシーケンス ====
　ではパラメータの値を複数（シーケンス）使用した場合はどうなるのでしょうか。 
valに複数の値(1|2)を入れてみます。（参照：[[PIONEの式#シーケンス]]） 

<pre>
/Basic6$ pione-client ParamEcho.pione -b ParamEcho --params="{val:(1|2)}"
"{val:(1|2)}"
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{main_val:(10)})
>>> &Anonymous:Main([],{main_val:(20)})
==> &Anonymous:Main([],{main_val:(10)})
--> Rule Application: &Anonymous:Main([],{main_val:(10)})
--> Distribution: &Anonymous:Main([],{main_val:(10)})
>>> &Anonymous:Sub([],{sub_val1:(10),sub_val2:(100)})
>>> &Anonymous:Sub([],{sub_val1:(10),sub_val2:(200)})
==> &Anonymous:Main([],{main_val:(20)})
--> Rule Application: &Anonymous:Main([],{main_val:(20)})
--> Distribution: &Anonymous:Main([],{main_val:(20)})
>>> &Anonymous:Sub([],{sub_val1:(20),sub_val2:(100)})
>>> &Anonymous:Sub([],{sub_val1:(20),sub_val2:(200)})
==> &Anonymous:Sub([],{sub_val1:(10),sub_val2:(100)})
SH ------------------------------------------------------------
SH echo "Basic Parameters:" > message.txt;
SH echo " val: 1 2" >> message.txt;
SH echo " b_val: 456" >> message.txt;
SH echo " b_val1: 135" >> message.txt;
SH echo " b_val2: 246" >> message.txt;
SH echo "Advanced Parameters:" >> message.txt;
SH echo " a_val: 987" >> message.txt;
SH echo " a_val1: 975" >> message.txt;
SH echo " a_val2: 864" >> message.txt;
SH echo "Parameters in Sub:" >> message.txt;
SH echo " sub_val1: 10" >> message.txt;
SH echo " sub_val2: 100" >> message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Sub([],{sub_val1:(10),sub_val2:(100)})
==> &Anonymous:Sub([],{sub_val1:(10),sub_val2:(200)})
SH ------------------------------------------------------------
SH echo "Basic Parameters:" > message.txt;
SH echo " val: 1 2" >> message.txt;
SH echo " b_val: 456" >> message.txt;
SH echo " b_val1: 135" >> message.txt;
SH echo " b_val2: 246" >> message.txt;
SH echo "Advanced Parameters:" >> message.txt;
SH echo " a_val: 987" >> message.txt;
SH echo " a_val1: 975" >> message.txt;
SH echo " a_val2: 864" >> message.txt;
SH echo "Parameters in Sub:" >> message.txt;
SH echo " sub_val1: 10" >> message.txt;
SH echo " sub_val2: 200" >> message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Sub([],{sub_val1:(10),sub_val2:(200)})
<-- Distribution: &Anonymous:Main([],{main_val:(10)})
<-- Rule Application: &Anonymous:Main([],{main_val:(10)})
<== &Anonymous:Main([],{main_val:(10)})
==> &Anonymous:Sub([],{sub_val1:(20),sub_val2:(100)})
SH ------------------------------------------------------------
SH echo "Basic Parameters:" > message.txt;
SH echo " val: 1 2" >> message.txt;
SH echo " b_val: 456" >> message.txt;
SH echo " b_val1: 135" >> message.txt;
SH echo " b_val2: 246" >> message.txt;
SH echo "Advanced Parameters:" >> message.txt;
SH echo " a_val: 987" >> message.txt;
SH echo " a_val1: 975" >> message.txt;
SH echo " a_val2: 864" >> message.txt;
SH echo "Parameters in Sub:" >> message.txt;
SH echo " sub_val1: 20" >> message.txt;
SH echo " sub_val2: 100" >> message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Sub([],{sub_val1:(20),sub_val2:(100)})
==> &Anonymous:Sub([],{sub_val1:(20),sub_val2:(200)})
SH ------------------------------------------------------------
SH echo "Basic Parameters:" > message.txt;
SH echo " val: 1 2" >> message.txt;
SH echo " b_val: 456" >> message.txt;
SH echo " b_val1: 135" >> message.txt;
SH echo " b_val2: 246" >> message.txt;
SH echo "Advanced Parameters:" >> message.txt;
SH echo " a_val: 987" >> message.txt;
SH echo " a_val1: 975" >> message.txt;
SH echo " a_val2: 864" >> message.txt;
SH echo "Parameters in Sub:" >> message.txt;
SH echo " sub_val1: 20" >> message.txt;
SH echo " sub_val2: 200" >> message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Sub([],{sub_val1:(20),sub_val2:(200)})
<-- Distribution: &Anonymous:Main([],{main_val:(20)})
<-- Rule Application: &Anonymous:Main([],{main_val:(20)})
<-- Distribution: &Anonymous:Root([],{})
<== &Anonymous:Main([],{main_val:(20)})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
/Basic6$
</pre>
デフォルトではval=(1|2)がeachとして動作します。この場合はmain_val=(10|20)となって、それぞれsub_val1=(10|20), sub_val2=(100|200)となります。 
このとき、sub_val1, sub_val2はともにeachですので、上記のように(10, 100), (10, 200), (20, 100), (20, 200)と2*2の組み合わせでルールが動きます。 

では、val=(1|2).allではどうなるでしょうか。 

<pre>
/Basic6$ pione-client ParamEcho.pione -b ParamEcho --params="{val:(1|2).all}"
"{val:(1|2).all}"
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{main_val:(10|20)})
==> &Anonymous:Main([],{main_val:(10|20)})
--> Rule Application: &Anonymous:Main([],{main_val:(10|20)})
--> Distribution: &Anonymous:Main([],{main_val:(10|20)})
>>> &Anonymous:Sub([],{sub_val1:(10|20),sub_val2:(100|200)})
==> &Anonymous:Sub([],{sub_val1:(10|20),sub_val2:(100|200)})
SH ------------------------------------------------------------
SH echo "Basic Parameters:" > message.txt;
SH echo " val: 1 2" >> message.txt;
SH echo " b_val: 456" >> message.txt;
SH echo " b_val1: 135" >> message.txt;
SH echo " b_val2: 246" >> message.txt;
SH echo "Advanced Parameters:" >> message.txt;
SH echo " a_val: 987" >> message.txt;
SH echo " a_val1: 975" >> message.txt;
SH echo " a_val2: 864" >> message.txt;
SH echo "Parameters in Sub:" >> message.txt;
SH echo " sub_val1: 10 20" >> message.txt;
SH echo " sub_val2: 100 200" >> message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Sub([],{sub_val1:(10|20),sub_val2:(100|200)})
<-- Distribution: &Anonymous:Main([],{main_val:(10|20)})
<-- Rule Application: &Anonymous:Main([],{main_val:(10|20)})
<== &Anonymous:Main([],{main_val:(10|20)})
<-- Distribution: &Anonymous:Root([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
/Basic6$
</pre>
allの場合はsub_val1=(10|20), sub_val2=(100|200)として組み合わせるので、上記のように１つのルールが動くだけです。 
このようにパラメータについてもeach, allを使うことでルールの振り分けが可能です。 

=== 基本７（条件文） ===
==== if文 ====
　今回はif文などを用いて実行したいルールを制御してみましょう。 

<pre>
param $val := 123

Rule Main
output 'message.txt'
Flow
if $val % 2 == 0
rule Even
else
rule Odd
end
End

Rule Even
output 'message.txt'
Action
echo "{$val} is even." > message.txt;
End

Rule Odd
output 'message.txt'
Action
echo "{$val} is odd." > message.txt;
End
</pre>

このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic7 こちら]からダウンロードできます。 
最初のパラメータvalに対して、偶数の場合と奇数の場合でそれぞれ別のルールを実行するようにしています。 
Rule Mainにif文がありますが、[[PIONE]]の記述ではif ~ endと記述します。 

では、valをデフォルト値で実行してみましょう。 

<pre>
/Basic7$ pione-client EvenOdd.pione -b EvenOdd
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{})
==> &Anonymous:Main([],{})
--> Rule Application: &Anonymous:Main([],{})
--> Distribution: &Anonymous:Main([],{})
>>> &Anonymous:Odd([],{})
==> &Anonymous:Odd([],{})
SH ------------------------------------------------------------
SH echo "123 is odd." > message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Odd([],{})
<-- Distribution: &Anonymous:Main([],{})
<-- Rule Application: &Anonymous:Main([],{})
<-- Distribution: &Anonymous:Root([],{})
<== &Anonymous:Main([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
/Basic7$ cat EvenOdd/output/message.txt
123 is odd.
/Basic7$
</pre>

val=123で定義されていますので、この場合は奇数のルールが動いているのが分かります。 

次にvalを偶数にして実行してみます。 

<pre>
/Basic7$ pione-client EvenOdd.pione -b EvenOdd --params="{val:456}"
"{val:456}"
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{})
==> &Anonymous:Main([],{})
--> Rule Application: &Anonymous:Main([],{})
--> Distribution: &Anonymous:Main([],{})
>>> &Anonymous:Even([],{})
==> &Anonymous:Even([],{})
SH ------------------------------------------------------------
SH echo "456 is even." > message.txt;
SH ------------------------------------------------------------
<== &Anonymous:Even([],{})
<-- Distribution: &Anonymous:Main([],{})
<-- Rule Application: &Anonymous:Main([],{})
<-- Distribution: &Anonymous:Root([],{})
<== &Anonymous:Main([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
/Basic7$ cat EvenOdd/output/message.txt
456 is even.
/Basic7$
</pre>

偶数のルールが動きます。 

以上のようにして条件に合わせてルールを制御することができます。 

==== case文 ====
　case文の場合は下記のように記述します。 

<pre>
case $val % 2
when 0
rule Even
else
rule Odd
end
</pre>

==== constraint ====
　constraintを使用して下記のように記述する方法もあります。 

<pre>
param $val := 123

Rule Main
output 'message.txt'
Flow
rule Even
rule Odd
End

Rule Even
output 'message.txt'
constraint $val % 2 == 0
Action
echo "{$val} is even." > {$O[1]};
End

Rule Odd
output 'message.txt'
constraint $val % 2 == 1
Action
echo "{$val} is odd." > {$O[1]};
End
</pre>

====[[デバッグのための条件文]]====
　条件文を使って、デバッグの切り替えの手間が少なくなる方法を考えてみましょう。 
 

=== 基本８（インタラクティブ操作） ===
　ここまでは、コマンドを実行すると結果出力までの動作を全てプログラムに委ねる、一方通行の処理を記述してきました。 
次は、処理の途中でユーザが操作できるようにし、それ以降の処理を制御(インタラクティブ操作)できるようにしてみましょう。 

今回はウェブページから選択した入力ファイルに対して、設定した演算子(+, *)、数値で計算したファイルを出力する処理を作成します。 
実行ファイル作成のためにパッケージを、実行のために[[PIONE Webclient]]を利用します。 

まず、インタラクティブ操作のための処理を[[PIONE定義書]]に記述します。 

<pre>
.@ PackageName :: "InteractiveCalc"

Rule Main
output '*.out'.all
Flow
rule Interaction
End

Rule Interaction
output '*.out'.all
Action
# build public directory for pione-interactive
mkdir public
cp etc/* public
cp bin/* public

echo "Interruption!" > result.log.out

# start interactive operation
pione-interactive browser --public public

cp public/* .
echo "finish!" > result.log.out
End
</pre>

この処理では、.outファイルを出力ファイルとしてダウンロードできるようにしています。 
[[pione-interactive]] browserコマンドにてInteractiveページを開けるようにします。 
このとき、--publicオプションで、ページのために使用する[[html]]ファイルや[[cgi]]ファイルなどがあるディレクトリを指定します。 
そのために、事前にディレクトリ(public)を用意し、そのディレクトリの下に、etcディレクトリ内とbinディレクトリ内のすべてのファイルをそれぞれコピーしています。 
また、Interactiveページを終了した後は、作成したファイルを処理できるようにpublicディレクトリ内のデータを全てワークスペース(.)へコピーしています。 

次に、ウェブページにて最初に呼び出されるindex.htmlを作成します。htmlファイルはetcディレクトリ内に置きます。 

<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>InteractiveCalc Index Page</title>
</head>
<body>
<form action="FileCalc.cgi" method="post" enctype="multipart/form-data">
入力ファイル名
<input type="file" name="inputfile"/>
 
演算子
<select name="operator">
<option value="add">+</option>
<option value="mul">*</option>
</select>
数値
<input type="text" name="value"/>
 
出力ファイル名
<input type="text" name="outputfile"/>
 
<button type="submit">計算開始</button>
</form>
 
 
<a href="?pione-action=finish">終了</a>
</body>
</html>
</pre>

最後の方にある<a href="?pione-action=finish">終了</a>は、「終了」をクリックするとワーキンングディレクトリに終了通知を行い、インタラクティブ操作を終了させる処理です。詳しくは[[インタラクションAPI]]をご覧下さい。 

そして、.cgiファイルを作成します。[[シェルスクリプト]]や[[Eosのコマンド]]などの特殊な処理はこのファイルに記述します。 
cgiファイルはbinディレクトリ内に置きます。 

<pre>
#!/usr/bin/env ruby

require 'cgi'

cgi = CGI.new

HTMLstr=""

# Main Process

## Query to Parameters
input_file=cgi.params['inputfile'][0]
output_path=cgi['outputfile']
operator=cgi['operator']
value=cgi['value'].to_i

## Calc input to output
output_file = open(output_path, "w")

HTMLstr += "<table>"
HTMLstr += "<tr>"
HTMLstr += "<td>" + input_file.original_filename.to_s + "</td>"
HTMLstr += "<td>" + output_path + "</td>"
HTMLstr += "</tr>"

input_file.each do |input_line|
HTMLstr += "<tr>"
HTMLstr += "<td>" + input_line + "</td>"

work_value = input_line.to_i

case operator
when "add"
work_value += value
when "mul"
work_value *= value
end

output_line = work_value.to_s
output_file.write(output_line + "\n")
HTMLstr += "<td>" + output_line + "</td>"
HTMLstr += "</tr>"
end

HTMLstr += "</table>"
output_file.close

# Output as html
cgi.out(type: "text/html") do
HTMLstr
end
</pre>

今回は[[Ruby]]を使って記述しています。# Output as html以下のコードで[[html]]形式に変換するようにしています。そのためにCGIクラスが必要なので、require 'cgi'とcgi = CGI.newで用意しています。このようにすると、# Main Process内のようにHTMLstrに記述する文字列を加えるだけで、自由な処理を行ってその結果を[[html]]のページを表示することができます。また、## Query to ParametersにてPOST形式のクエリを変数に変換していますが、typeがfileの場合、ファイル本体はCGIクラスメンバーParamsから受け取ります。このとき受け取るデータはファイルポインタ配列ですので、取得したい要素No.を指定する必要があります。今回、入力ファイルは１つしか格納していないので、cgi.params['inputfile'][0]となります。 

コードが完成したら、[[パッケージ作成]]を行います。([[PIONEチュートリアル-package]]を参照) 
なお、これらのファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic8 こちら]からダウンロードできます。 

<pre>
/PIONE$ pione package build Basic8/
info: update the package info file: local:/Eos/tutorial/SampleCode/PIONE/Basic8/pione-package.json
info: Package local:/Eos/tutorial/SampleCode/PIONE/InteractiveCalc.ppg has been built successfully.
</pre>

作成した[[パッケージ]]は[[PIONE Webclient]]にて動かすことができます。[[PIONE Webclientチュートリアル#インタラクティブ操作を含むコマンドを実行]]にて動作方法と実行結果を記載しています。 
 
index.htmlとFileCalc.cgiで作成したページ 
<table>
<tr>
<td>[[画像:PIONE-Webclient13.png|border]]</td>
<td>-></td>
<td>[[画像:PIONE-Webclient14.png|border]]</td>
</tr>
</table>
 

=== 基本９（[[インタラクションAPI]]の使用） ===
　[[インタラクションAPI]]を使用してワーキングディレクトリに通知を送ることで、ファイル操作や終了などを命令することができます。.htmlや.cgiに記述することにより、[[ユーザ]]からの操作を受けてこれらの命令を実行することができます。 
 

Annotation.pione
<pre>
.@ PackageName :: "FileOperation"
.@ Editor :: "Kinoshita"
.@ Tag :: "v0.1.0"
</pre>
 

Main.pione 

<pre>
Rule Main
output '*.txt'.all
Flow
rule Interaction
End
</pre>

今回は.txtファイルのみを出力するようにしています。 

Interaction.pione
<pre>
Rule Interaction
output '*.*'.all
Action
# build public directory for pione-interactive
mkdir public
cp etc/* public
cp bin/* public

# start interactive operation
pione-interactive browser --public public

cp public/* .
End
</pre>

etc/index.html 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>FileOperation</title>
</head>
<body>
<form action="./AAA.txt" method="post" enctype="multipart/form-data">
<input type="hidden" name="pione-action" value="create"/>
<button type="submit">作成（ファイル）</button>
<input type="file" name="pione-content" value=""/>
</form>
<form action="./AAA.txt" method="post" enctype="multipart/form-data">
<input type="hidden" name="pione-action" value="create"/>
<button type="submit">作成（テキスト）</button>
<input type="text" name="pione-content" value=""/>
</form>
<form action="./AAA.txt" method="post" enctype="multipart/form-data">
<input type="hidden" name="pione-action" value="delete"/>
<button type="submit">削除</button>
</form>
<form action="./list.cgi" method="post" enctype="multipart/form-data">
<input type="hidden" name="pione-action" value="get"/>
<button type="submit">ファイル一覧の取得</button>
</form>
 
 
<a href="?pione-action=finish">終了</a>
</body>
</html>
</pre>

それぞれのボタンよりファイル操作を行います。 
<table>
<tr>
<td>作成（ファイル）：</td>
<td>指定したファイルをサーバ上のファイル(AAA.txt)に書き込んでアップロードします。</td>
</tr>
<tr>
<td>作成（テキスト）：</td>
<td>指定したテキストボックスの内容でサーバ上のファイル(AAA.txt)に書き込みます。</td>
</tr>
<tr>
<td>削除：</td>
<td>サーバ上のファイル(AAA.txt)内容を削除します。</td>
</tr>
<tr>
<td>ファイル一覧の取得：</td>
<td>サーバ上のファイル一覧を表示します。(list.cgiが動作します)</td>
</tr>
<tr>
<td>終了：</td>
<td>操作を終了します。</td>
</tr>
</table>

etc/list.cgi 
<pre>
#!/usr/bin/env ruby

require 'cgi'

cgi = CGI.new

strHTML = ""

strHTML += <<'Block-HTML'
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>CGIページ</title>
</head>
<body>
<script src="http://code.jquery.com/jquery-1.11.1.min.js"></script>
<div id="textDiv"></div>
<script type="text/javascript">
var div = document.getElementById("textDiv");
div.textContent = "";
$.getJSON("./", {"pione-action": "list"}, function(data){
$.each(data, function(file) {
div.textContent += this.name +"\n";
});
});
</script>
<a href="Index.html">戻る</a>
 
 
<a href="?pione-action=finish">終了</a>
</body>
</html>
Block-HTML

# Output as html
cgi.out(type: "text/html") do
strHTML
end
</pre>

"./"に対して"pione-action=list"を送信したときの戻り値をgetJSONにより取得して、データ毎の"name"を出力するようにしています。 

これらのファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic9 こちら]からダウンロードできます。 
では、実行させてみましょう。 

インタラクションページを開くと下記のようになっています。 
[[画像:Outdata-PIONE-Basic9-1.png|border]] 

まずは選択...ボタンからテキストファイルを選択し、作成（ファイル）ボタンでサーバ内にファイルを作成（アップロード）してみましょう。 
[[画像:Outdata-PIONE-Basic9-2.png|border]] 
これによりAAA.txtが同じ内容で作成(アップロード)されます。終了した後にダウンロードすると/output/AAA.txtの内容を確認できます。 

また、ファイル一覧の取得ボタンよりサーバ上のファイル一覧を閲覧することができます。 
[[画像:Outdata-PIONE-Basic9-3.png|border]] 
AAA.txtが確認できます。 

そして削除ボタンを押すと、AAA.txtを削除します。 
[[画像:Outdata-PIONE-Basic9-4.png|border]] 
AAA.txtがなくなっているのが確認できます。 

次はテキストボックスに文字列を書き込んで、作成（テキスト）ボタンを押してみましょう。 
[[画像:Outdata-PIONE-Basic9-2.png|border]] 
これによりAAA.txtがテキストの内容で作成されます。 

操作を終えるときには終了をクリックして下さい。終了通知が送られてインタラクティブ処理が完了します。 
また、htmlなどを実装する上で終了時には必ず終了通知finishを送信するように注意しましょう。 

=== 基本１０（ループ文） ===
　[[PIONE定義書]]にてループ文を作成してみましょう。 
Action内はシェルスクリプトですので、for文やwhile文を使用することで容易にループを実現できます。 
しかし、Actionに記述した処理は一つのルールに書かれるため、一かたまりの処理として一つのマシンで実行されてしまいます。 
それでは、処理を分割できる[[PIONE]]の長所を活かせていません。 
ループ内の一つひとつの処理を分割し、複数のマシンで短時間に処理を行うことを考えましょう。 

そこで、Flowでループ文に相当する内容を作成し、ループ内の個別の処理を各々のマシンに振り分ける工夫を施します。 

今回は、[[#基本７（制御文）]]での偶数奇数判定の処理を、最小値から最大値まで加算値を加算しながら行っていくプログラムを作成します。 
このプログラムは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic10 こちら]からダウンロードできます。 
最大値、最小値、加算値をパラメータで設定できるようにし、ルールLoopSystemにてループ文を実現しています。 

<pre>
param $maxval := 456
param $minval := 123
param $dval := 37

Rule Main
output '*.txt'
Flow
rule LoopSystem {val: $minval}
End

Rule LoopSystem
output '*.txt'
param $val
Flow
if $val <= $maxval
rule EvenOdd {val: $val}
end
if ($val + $dval) <= $maxval
rule LoopSystem {val: $val + $dval}
end
End

Rule EvenOdd
output '*.txt'
param $val
Flow
if $val % 2 == 0
rule Even {val: $val}
else
rule Odd {val: $val}
end
End

Rule Even
output '*.txt'
param $val
Action
echo "{$val} is even." >> Even{$val}.txt;
End

Rule Odd
output '*.txt'
Action
echo "{$val} is odd." >> Odd{$val}.txt;
End
</pre>

まず、MainルールからLoopSystemをval=最小値で呼び出し、その中でvalが最大値になるまでは加算値を加えながら再帰的にLoopSystemを呼び出しています。 
出力ファイル名を偶数のときはEven{$val}.txt、奇数のときはOdd{$val}.txtとしています。 

では、実行してみます。 

<pre>
/Basic10$ pione-client EvenOddLoop.pione
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{})
==> &Anonymous:Main([],{})
--> Rule Application: &Anonymous:Main([],{})
--> Distribution: &Anonymous:Main([],{})
>>> &Anonymous:LoopSystem([],{val:(123)})
==> &Anonymous:LoopSystem([],{val:(123)})
--> Rule Application: &Anonymous:LoopSystem([],{val:(123)})
--> Distribution: &Anonymous:LoopSystem([],{val:(123)})
>>> &Anonymous:EvenOdd([],{val:(123)})
>>> &Anonymous:LoopSystem([],{val:(160)})
==> &Anonymous:EvenOdd([],{val:(123)})
--> Rule Application: &Anonymous:EvenOdd([],{val:(123)})
--> Distribution: &Anonymous:EvenOdd([],{val:(123)})
>>> &Anonymous:Odd([],{val:(123)})
==> &Anonymous:LoopSystem([],{val:(160)})
--> Rule Application: &Anonymous:LoopSystem([],{val:(160)})
--> Distribution: &Anonymous:LoopSystem([],{val:(160)})
>>> &Anonymous:EvenOdd([],{val:(160)})
>>> &Anonymous:LoopSystem([],{val:(197)})
==> &Anonymous:Odd([],{val:(123)})
SH ------------------------------------------------------------
SH echo "123 is odd." >> Odd123.txt;
SH ------------------------------------------------------------
<== &Anonymous:Odd([],{val:(123)})

-中略-

==> &Anonymous:Even([],{val:(456)})
SH ------------------------------------------------------------
SH echo "456 is even." >> Even456.txt;
SH ------------------------------------------------------------
<== &Anonymous:Even([],{val:(456)})
<-- Distribution: &Anonymous:EvenOdd([],{val:(456)})
<-- Rule Application: &Anonymous:EvenOdd([],{val:(456)})
<== &Anonymous:EvenOdd([],{val:(456)})

-中略-

<-- Distribution: &Anonymous:LoopSystem([],{val:(160)})
<-- Rule Application: &Anonymous:LoopSystem([],{val:(160)})
<== &Anonymous:LoopSystem([],{val:(160)})
<-- Distribution: &Anonymous:LoopSystem([],{val:(123)})
<-- Rule Application: &Anonymous:LoopSystem([],{val:(123)})
<== &Anonymous:LoopSystem([],{val:(123)})
<-- Distribution: &Anonymous:Main([],{})
<-- Rule Application: &Anonymous:Main([],{})
<-- Distribution: &Anonymous:Root([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
<== &Anonymous:Main([],{})
</pre>

今回はパラメータをデフォルト値で実行しましたので、123から456まで37刻みで実行されます。lsコマンドで出力ファイルを確認します。 

<pre>
/Basic10$ ls process/output/
Even160.txt Even308.txt Even456.txt Odd197.txt Odd345.txt
Even234.txt Even382.txt Odd123.txt Odd271.txt Odd419.txt
</pre>

それぞれの値について偶数奇数の処理が実行されていることが確認できました。 

=== 基本１１（ループ文２） ===
　[[#基本１０（ループ文）]]でループの作成方法を示しました。 
しかし、[[#基本１０（ループ文）]]の書き方では逐次処理となってしまうので、ループ数に比例して処理時間が掛かってしまいます。 
この問題を解決する方法を考えましょう。 
以下に示すのは、val=0がmax=64になるまで1を足し続け、{$val}.txtを作成する、ループを使った処理の例です。 
以下に示していくファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic11 こちら]からダウンロードできます。 

<pre>
param $max := 64

Rule Main
output '*.txt'
Flow
rule LoopSystem {val: 0}
End

Rule LoopSystem
output '*.txt'
param $val
Flow
rule Test {val: $val}
if $val + 1 <= $max
rule LoopSystem {val: $val + 1}
end
End

Rule Test
output '{$val}.txt'
param $val
Action
touch {$O[1]}
End
</pre>

このままでは、[[#基本１０（ループ文）]]同様、ループ部分は、逐次処理になっています。 
そこで、ループの箇所を下記のような分割した形に書き換え、並列処理を試みます。 

<pre>
Rule LoopSystem
output '*.txt'
param $val
Flow
rule Test {val: $val}
if ($val * 2) + 1 <= $max
rule LoopSystem {val: ($val * 2) + 1}
end
if ($val * 2) + 2 <= $max
rule LoopSystem {val: ($val * 2) + 2}
end
End
</pre>

このようにすることでループに掛かる時間が改善されます。 

あるいはconstraintを使用して下記のように記述する方法もあります。 

<pre>
Rule LoopSystem
output '*.txt'
param $val
constraint $val <= $max
Flow
rule Test {val: $val}
rule LoopSystem {val: ($val * 2) + 1}
rule LoopSystem {val: ($val * 2) + 2}
End
</pre>

また、valの値を加算している箇所ですが、 

<pre>
rule LoopSystem {val: ($val * 2) + 1}
rule LoopSystem {val: ($val * 2) + 2}
</pre>

シーケンスを利用して下記のように書くこともできます。（参照：[[PIONEの式#シーケンス]]） 

<pre>
rule LoopSystem {val: ($val * 2) + (1|2)}
</pre>

問題：これを踏まえて[[#基本１０（ループ文）]]のループを改善してみましょう。 

解答例１ 
<pre>
Rule LoopSystem
output '*.txt'.all
param $val
Flow
if $val <= $maxval
rule EvenOdd {val: $val}
end
if (($val * 2) - $minval) + $dval <= $maxval
rule LoopSystem {val: (($val * 2) - $minval) + $dval}
end
if (($val * 2) - $minval) + ($dval * 2) <= $maxval
rule LoopSystem {val: (($val * 2) - $minval) + ($dval * 2)}
end
End
</pre>

Flow内の条件を分割しています。条件式が多少複雑になっていますので、演算の順番に注意しましょう。 
また、現在のバージョンでの四則演算は二項演算のみの対応となっていますので、三項以上の場合は必ず括弧で括るようにして下さい（参照：[[PIONEの式#四則演算における注意事項]]）。 

解答例２：constraintとシーケンスを利用した場合 
<pre>
Rule LoopSystem
output '*.txt'.all
param $val
constraint $val <= $maxval
Flow
rule EvenOdd {val: $val}
rule LoopSystem {val: (($val * 2) - $minval) + ($dval * (1|2))}
End
</pre>

これにより[[#基本１０（ループ文）]]よりも呼び出されるルールの階層は浅くなります。 
しかし、いずれも入れ子で呼び出されるのでルールが多くなるほど処理が重くなるでしょう。 
そこで１つのルールから一気にループ数だけのルールを呼び出す方法を考えます。この記述方法については[[#基本１５（ループ文３）]]をご覧下さい。 

=== 基本１２（チケット） ===
[[PIONE]]の目的の一つは、できる限り並列処理を行うことですので、必ずしも記述の順番通りにルールが実行される訳ではありません。 
ルールに順番を持たせたいときにはチケットという機能を利用します。但し、使い過ぎると待ち時間が多くなり並列計算できる[[PIONE]]の長所が活かせなくなってしまいますので注意が必要です。 
 

下記の内容をご覧下さい。(CreateList-instant.pione) 
このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic12 こちら]からダウンロードできます。 
<pre>
Rule Main
input '*.data'.all
output 'list.txt'
Flow
rule Touch0
rule CreateList
End

Rule Touch0
output '0.data'
Action
sleep 1
touch {$O[1]}
End

Rule CreateList
input '*.data'.all
output 'list.txt'
Action
ls *.data > {$O[1]}
End
</pre>
これはCreateListで.dataファイルの一覧をlist.txtに記述する処理ですが、途中のTouch0でも0.dataファイルを作成しています。 
この0.dataが一覧に含まれるかを検証してみましょう。 
 

入力ファイル用のディレクトリ(input)内
<pre>
/Basic12$ ls input/
1.data 2.data
</pre>
 

まずはMainルールを上記のようにそのまま記述している場合で実行してみます。 
<pre>
/Basic12$ pione-client CreateList-instant.pione -i input/
==> &Anonymous:Root([.DS_Store,1.data,2.data],{})
--> Rule Application: &Anonymous:Root([.DS_Store,1.data,2.data],{})
--> Distribution: &Anonymous:Root([.DS_Store,1.data,2.data],{})
>>> &Anonymous:Main([1.data,2.data],{})
==> &Anonymous:Main([1.data,2.data],{})
--> Rule Application: &Anonymous:Main([1.data,2.data],{})
--> Distribution: &Anonymous:Main([1.data,2.data],{})
>>> &Anonymous:Touch0([],{})
>>> &Anonymous:CreateList([1.data,2.data],{})
==> &Anonymous:Touch0([],{})
SH ------------------------------------------------------------
SH sleep 1
SH touch 0.data
SH ------------------------------------------------------------
<== &Anonymous:Touch0([],{})
==> &Anonymous:CreateList([1.data,2.data],{})
SH ------------------------------------------------------------
SH ls *.data > list.txt
SH ------------------------------------------------------------
<== &Anonymous:CreateList([1.data,2.data],{})
<-- Distribution: &Anonymous:Main([1.data,2.data],{})
<-- Rule Application: &Anonymous:Main([1.data,2.data],{})
<-- Distribution: &Anonymous:Root([.DS_Store,1.data,2.data],{})
<== &Anonymous:Main([1.data,2.data],{})
<-- Rule Application: &Anonymous:Root([.DS_Store,1.data,2.data],{})
<== &Anonymous:Root([.DS_Store,1.data,2.data],{})
</pre>
 

では出力ファイルlist.txtを確認してみます。 
<pre>
/Basic12$ cat process/output/list.txt
1.data
2.data
</pre>
0.dataが含まれませんでした。 
これはTouch0とCreateListが同時に動き、Touch0が完了する前にCreateListが実行されているため、作成された0.dataがCreateListの入力ファイルとして登録されなかったからです。 
 

では、チケットの機能を使ってMainルールを下記のようにしてみます。 
<pre>
Rule Main
input '*.data'.all
output 'list.txt'
Flow
rule Touch0 ==> <T>
rule <T> ==> CreateList
End
</pre>
上記のようにチケット名は<>で囲んで、ルールとチケット間を==>で繋いで使用します。 

 

チケット名を省略したい場合は下記のように記述します。 
<pre>
rule Touch0 >>> CreateList
</pre>
 

下記のように連続させることも可能です。 
<pre>
rule First >>> Second >>> Third
</pre>
 

また複数チケットの発行もできます。 
<pre>
rule Touch0 ==> (<T1>|<T2>)
rule <T1> ==> CreateList
rule <T2> ==> CreateList2
</pre>
 

逆に複数チケットからのルール実行も可能です。 
<pre>
rule Touch0 ==> <T0>
rule Touch1 ==> <T1>
rule (<T0>|<T1>) ==> CreateList
</pre>
上記の場合はチケットT0かつT1が発行されてからCreateListが実行されます。 
 

では、実行してみます。 
<pre>
/Basic12$ pione-client CreateList-ticket.pione -i input/
==> &Anonymous:Root([.DS_Store,1.data,2.data],{})
--> Rule Application: &Anonymous:Root([.DS_Store,1.data,2.data],{})
--> Distribution: &Anonymous:Root([.DS_Store,1.data,2.data],{})
>>> &Anonymous:Main([1.data,2.data],{})
==> &Anonymous:Main([1.data,2.data],{})
--> Rule Application: &Anonymous:Main([1.data,2.data],{})
--> Distribution: &Anonymous:Main([1.data,2.data],{})
>>> &Anonymous:Touch0([],{})
==> &Anonymous:Touch0([],{})
SH ------------------------------------------------------------
SH sleep 1
SH touch 0.data
SH ------------------------------------------------------------
<== &Anonymous:Touch0([],{})
<-- Distribution: &Anonymous:Main([1.data,2.data],{})
--> Distribution: &Anonymous:Main([1.data,2.data],{})
>>> &Anonymous:CreateList([1.data,2.data,0.data],{})
==> &Anonymous:CreateList([1.data,2.data,0.data],{})
SH ------------------------------------------------------------
SH ls *.data > list.txt
SH ------------------------------------------------------------
<== &Anonymous:CreateList([1.data,2.data,0.data],{})
<-- Distribution: &Anonymous:Main([1.data,2.data],{})
<-- Rule Application: &Anonymous:Main([1.data,2.data],{})
<-- Distribution: &Anonymous:Root([.DS_Store,1.data,2.data],{})
<== &Anonymous:Main([1.data,2.data],{})
<-- Rule Application: &Anonymous:Root([.DS_Store,1.data,2.data],{})
<== &Anonymous:Root([.DS_Store,1.data,2.data],{})
/Basic12$ cat process/output/list.txt
0.data
1.data
2.data
</pre>
今度は0.dataが含まれるようになりました。 
 

=== 基本１３（orの使用例） ===
inputやoutputで宣言するときにorや|で繋ぐと、指定した複数種類のファイルからいずれかを入力や出力に使用することができます。 
以下で使用するファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic13 こちら]からダウンロードできます。 
 

==== 入力ファイルでの使用例 ====
<pre>
Rule Main
input '1.txt' or '2.txt' or '3.txt'
output 'out.txt'
Action
cp {$I[1]} {$O[1]}
End
</pre>
上記では入力ファイルに1.txt, 2.txt, 3.txtのいずれかがあればout.txtにコピーする処理となっています。 
 

例えば2.txtだけあった場合でも実行されます。 
<pre>
/Basic13$ pione-client test.pione -i ./input/
==> &Anonymous:Root([.DS_Store,2.txt],{})
--> Rule Application: &Anonymous:Root([.DS_Store,2.txt],{})
--> Distribution: &Anonymous:Root([.DS_Store,2.txt],{})
>>> &Anonymous:Main([2.txt],{})
==> &Anonymous:Main([2.txt],{})
SH ------------------------------------------------------------
SH cp 2.txt out.txt
SH ------------------------------------------------------------
<== &Anonymous:Main([2.txt],{})
<-- Distribution: &Anonymous:Root([.DS_Store,2.txt],{})
<-- Rule Application: &Anonymous:Root([.DS_Store,2.txt],{})
<== &Anonymous:Root([.DS_Store,2.txt],{})
</pre>
上記の使用例は入力ファイルが１つだけあった場合のみに対応しています。 
複数のファイルがあった場合、複数ファイルで上書きコピーされてしまいます。 
 

==== 出力ファイルでの使用例 ====
<pre>
param $Mode := 1

Rule Main
output 'out1.txt' or 'out2.txt' or 'err.txt'
Action
if [ {$Mode} -eq 1 ] ; then
echo "Mode: {$Mode}" > {$O[1].nth(1)}
elif [ {$Mode} -eq 2 ] ;then
echo "Mode: {$Mode}" > {$O[1].nth(2)}
else
echo "Error: Mode {$Mode} is not Supported!" > {$O[1].nth(3)}
fi
End
</pre>
これはパラメータModeが1のときはout1.txtを作成し、2のときはout2.txtを作成し、それ以外についてはエラーを残す処理となっています。 
out1.txt, out2.txt, err.txtのいずれかが出力されることで処理が完了しますので、状況に応じて作成するファイルを変えたいときに有効です。 
.nth()は引数で指定した要素を取り出すシーケンスのメソッドです。（参照：[[PIONEの式#シーケンス]]） 
 

デフォルト（Mode=1）で実行してみます。 
<pre>
/Basic13$ pione-client OutputOr.pione
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{})
==> &Anonymous:Main([],{})
SH ------------------------------------------------------------
SH if [ 1 -eq 1 ] ; then
SH echo "Mode: 1" > out1.txt
SH elif [ 1 -eq 2 ] ;then
SH echo "Mode: 1" > out2.txt
SH else
SH echo "Error: Mode 1 is not Supported!" > err.txt
SH fi
SH ------------------------------------------------------------
<-- Distribution: &Anonymous:Root([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
<== &Anonymous:Main([],{})
/Basic13$ cat process/output/out1.txt
Mode: 1
</pre>
out1.txtが作成されて完了します。 
 

Mode=0で実行してみます。 
<pre>
/Basic13$ pione-client OutputOr.pione --params={Mode:0}
"{Mode:0}"
==> &Anonymous:Root([],{})
--> Rule Application: &Anonymous:Root([],{})
--> Distribution: &Anonymous:Root([],{})
>>> &Anonymous:Main([],{})
==> &Anonymous:Main([],{})
SH ------------------------------------------------------------
SH if [ 0 -eq 1 ] ; then
SH echo "Mode: 0" > out1.txt
SH elif [ 0 -eq 2 ] ;then
SH echo "Mode: 0" > out2.txt
SH else
SH echo "Error: Mode 0 is not Supported!" > err.txt
SH fi
SH ------------------------------------------------------------
<-- Distribution: &Anonymous:Root([],{})
<== &Anonymous:Main([],{})
<-- Rule Application: &Anonymous:Root([],{})
<== &Anonymous:Root([],{})
/Basic13$ cat process/output/err.txt
Error: Mode 0 is not Supported!
</pre>
err.txtが作成されて完了します。 

=== 基本１４（例外） ===
[[PIONE]]でも入出力ファイルにワイルドカード*を使用して全ての該当ファイルを対象とできますが、exceptを使用することにより対象外とするファイルを指定できます。メソッドexcept, exceptionsについては[[PIONEの式#データ表現型]]を参照して下さい。 
 

<pre>
Rule Main
input 'AllData.txt'
output '*.txt'.all.except($I[1])
Flow
rule GetLine {filename:"Data1", line:1}
rule GetLine {filename:"Data2", line:2}
rule GetLine {filename:"Data3", line:3}
End

Rule GetLine
input 'AllData.txt'
output '{$filename}.txt'
param $filename
param $line
Action
head -{$line} {$I[1]} | tail -1 > {$O[1]}
End
</pre>
上記はAllData.txtから1, 2, 3行目を指定した.txtファイルに出力する処理です。出力ファイルは全ての.txtとしていますが、exceptによってAllData.txtを対象外としています。対象外としていない場合はAllData.txtが出力ファイルの条件を満たしていますので、発火しません。 
このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic14 こちら]からダウンロードできます。
 

AllData.txtを下記の内容として実行してみます。 
<pre>
ABC
DEF
GHI

</pre>
 

実行結果 
<pre>
/Basic14$ pione-client DivideText.pione -i DivideTextInput/
==> &Anonymous:Root([.DS_Store,AllData.txt],{})
--> Rule Application: &Anonymous:Root([.DS_Store,AllData.txt],{})
--> Distribution: &Anonymous:Root([.DS_Store,AllData.txt],{})
>>> &Anonymous:Main([AllData.txt],{})
==> &Anonymous:Main([AllData.txt],{})
--> Rule Application: &Anonymous:Main([AllData.txt],{})
--> Distribution: &Anonymous:Main([AllData.txt],{})
>>> &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data1"),line:(1)})
>>> &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data2"),line:(2)})
==> &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data1"),line:(1)})
SH ------------------------------------------------------------
SH head -1 AllData.txt | tail -1 > Data1.txt
SH ------------------------------------------------------------
>>> &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data3"),line:(3)})
<== &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data1"),line:(1)})
==> &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data2"),line:(2)})
SH ------------------------------------------------------------
SH head -2 AllData.txt | tail -1 > Data2.txt
SH ------------------------------------------------------------
<== &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data2"),line:(2)})
==> &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data3"),line:(3)})
SH ------------------------------------------------------------
SH head -3 AllData.txt | tail -1 > Data3.txt
SH ------------------------------------------------------------
<== &Anonymous:GetLine([AllData.txt],{filename:(<s>"Data3"),line:(3)})
<-- Distribution: &Anonymous:Main([AllData.txt],{})
<-- Rule Application: &Anonymous:Main([AllData.txt],{})
<-- Distribution: &Anonymous:Root([.DS_Store,AllData.txt],{})
<== &Anonymous:Main([AllData.txt],{})
<-- Rule Application: &Anonymous:Root([.DS_Store,AllData.txt],{})
<== &Anonymous:Root([.DS_Store,AllData.txt],{})
/Basic14$ cat process/output/Data1.txt
ABC
/Basic14$ cat process/output/Data2.txt
DEF
/Basic14$ cat process/output/Data3.txt
GHI
</pre>
1, 2, 3行目の内容がそれぞれのファイルに出力されました。 
 

.except($I[1])を除いた場合は発火しません。 
<pre>
/Basic14$ pione-client DivideText.pione -i DivideTextInput/
==> &Anonymous:Root([.DS_Store,AllData.txt],{})
--> Rule Application: &Anonymous:Root([.DS_Store,AllData.txt],{})
<-- Rule Application: &Anonymous:Root([.DS_Store,AllData.txt],{})
<== &Anonymous:Root([.DS_Store,AllData.txt],{})
</pre>
 

また、exceptionsを使用すると設定している例外をリストで得ることができます。 
<pre>
Rule Main
input '1.txt'
input '2.txt'
input '3.txt'
output '*.txt'.all.except($I[1] or $I[2] or $I[3])
Action
for data in {$O[1].exceptions()}
do
cat $data >> AllData.txt
wc $data >> AllInfo.txt
done
End
</pre>
上記の例ではoutputに例外が$I[1] or $I[2] or $I[3]と設定されているので、{$O[1].exceptions()}では1.txt 2.txt 3.txtのリストとして得られるので、for文がこれらのファイルによって回ることになります。 
 

=== 基本１５（ループ文３） ===
[[#基本１０（ループ文）]]、[[#基本１１（ループ文２）]]にてループ文を記述する方法を示しました。しかし、いずれも多くのルールを入れ子で呼ぶことになり、ループ数が多くなると入出力ファイルの引き継ぎも多くなり時間が掛かってしまいます。今回は一つのルールから全てのルールを呼び出すようにしてループを行うようにしてみます。 
 

下記の整数型メソッドuptoを使用すると、１つのルールからパラメータを一気に設定して各々の値でルールを実行することができます。uptoは引数の値まで１ずつ加算しながら整数を返すメソッドです。（参照：[[PIONEの式#整数型(integer)]]）
<pre>
param $min := 0
param $max := 64

Rule Main
output '*.txt'
Flow
rule Test {val: $min.upto($max)}
End

Rule Test
output '{$val}.txt'
param $val
Action
touch {$O[1]}
End
</pre>
 

またdowntoを使用する方法もあります。uptoは引数の値まで１ずつ減算しながら整数を返すメソッドです。（参照：[[PIONEの式#整数型(integer)]]） 
<pre>
rule Test {val: $max.downto($min)}
</pre>
 

uptoを利用すると、[[#基本１０（ループ文）]]は下記のようになります。 
<pre>
param $maxval := 456
param $minval := 123
param $dval := 37

Rule Main
output '*.txt'.all
Flow
rule EvenOdd {val: $minval + ($dval * (0.upto(($maxval - $minval)/$dval)))}
End

Rule EvenOdd
output '*.txt'
param $val
Flow
if $val % 2 == 0
rule Even {val: $val}
else
rule Odd {val: $val}
end
End

Rule Even
output '*.txt'
param $val
Action
echo "{$val} is even." >> Even{$val}.txt;
End

Rule Odd
output '*.txt'
Action
echo "{$val} is odd." >> Odd{$val}.txt;
End
</pre>このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic15 こちら]からダウンロードできます。
 

valに設定する式が複雑な場合は下記のように一旦、[[変数束縛]]で計算したものを利用する方法もあります。 
<pre>
param $maxval := 456
param $minval := 123
param $dval := 37
$loop := ($maxval - $minval)/$dval

Rule Main
output '*.txt'.all
Flow
rule EvenOdd {val: $minval + ($dval * (0.upto($loop))}
End

-以下略-
</pre>
上記の場合は変数loopにパラメータから計算したループ数を設定しています。 
 

=== 基本１６（ランダム） ===
メソッドrandomを使用するとランダムに選んだファイルを出力することができます。（現v0.5.0では未実装） 
 

<pre>
Rule Main
input '*.txt'
output '*.out'.all.random
Action
max=$(wc -l {$I[1]} | awk '{print $1}')
for (( i=1; i<${max}; i++ ))
do
head -${i} {$I[1]} | tail -1 > {$I[1][1]}-{$i}.out
done
End
</pre>
上記の例では入力.txtファイルからランダムに選んだ行数を.outファイルとして出力します。このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Basic16 こちら]からダウンロードできます。 
 

== 応用 ==
さて、ここまでの基本を組み合わせて、[[Eosのコマンド]]を使用する問題を考えてみましょう。 
 

=== 応用１（フローの制御）===
==== 問題１ ====
<div>*.mrc（[[mrcImage]]）と*.prametersで指定される入力ファイルがあります。</div>
<div>それぞれの*.mrcファイルから最大値を中心として切り出した*.roiを出力するCenterGet.pioneを考えてみましょう。 
但し、*.parametersは以下のフォーマットで切り出しサイズ(Sx, Sy, Sz)を格納しているファイルとします。</div>
 

<div>*.parametersのフォーマット</div>
<pre>
Sx Sy Sz
</pre>
 

-----

　応用問題１：上記のCenterGet.pioneを作成してみましょう。

-----
 

==== 解答例 ====
<pre>
Rule Main
input '*.mrc'.all
output '*.roi'
Flow
rule First
rule Second
End

Rule First
input '*.mrc'
output '{$I[1]}.info'
Action
mrcImageInfo -I -i {$I[1]} \
| head -2 | tail -1 \
| awk '{printf("%s %s %s", $3, $4, $5)}' \
| tr -c '[0-9]' ' ' \
> {$O[1]}
End

Rule Second
input '*.mrc'
input '{$I[1]}.info'
input '{$I[1][1]}.parameters'
output '{$I[1][1]}.roi'
Action
Center_x=$(awk '{printf("%s\n", $1)}' {$I[2]})
Center_y=$(awk '{printf("%s\n", $2)}' {$I[2]})
Center_z=$(awk '{printf("%s\n", $3)}' {$I[2]})
N_x=$(awk '{printf("%s\n", $1)}' {$I[3]})
N_y=$(awk '{printf("%s\n", $2)}' {$I[3]})
N_z=$(awk '{printf("%s\n", $3)}' {$I[3]})
mrcImageCenterGet -i {$I[1]} -o {$O[1]} \
-Cx $Center_x -Cy $Center_y -Cz $Center_z \
-Nx $N_x -Ny $N_y -Nz $N_z
End
</pre>
このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Advanced1 こちら]からダウンロードできます。 
 
主に[[mrcImageCenterGet]]を用いて切り出しを行っています。 
<pre>
Main: .mrcファイルについてFirst, Secondの処理を行います。
First: .mrcファイルの最大値の座標を得て、.mrc.infoファイルに格納します。
Second: .mrcから.mrc.infoの座標を中心に.parametersのサイズで切り出しを行います。
</pre>
 

==== 実行結果 ====
入力ファイル 
[[:Media:1VOM.mrc|mrcファイル1]]
<table>
<tr>
<td>[[画像:Input-1VOM.png]] 
xy平面 
</td>
<td>[[画像:Input1-1VOM.png]] 
yz平面 
</td>
</tr>
</table>
<pre>
Min: 0 (0, 0, 0)
Max: 3398.12 (23, 55, 41)
Mean: 72.129
SD: 294.805
SE: 0.368507
Sum: 4.61626e+07
</pre>
最大値の座標: (23, 55, 41) 
 

[[:Media:Input-1VOM-N.mrc|mrcファイル2]]
<table>
<tr>
<td>[[画像:Input-1VOM-N.png]] 
xy平面 
</td>
<td>[[画像:Input1-1VOM-N.png]] 
yz平面 
</td>
</tr>
</table>
<pre>
Min: -2390.42 (77, 14, 69)
Max: 4374.62 (17, 62, 46)
Mean: 72.1487
SD: 577.82
SE: 0.722275
Sum: 4.61752e+07
</pre>
最大値の座標: (17, 62, 46) 
 

parametersファイル1, 2の両方を下記に設定して実行してみます。 
<pre>
40 40 50
</pre>
 

コマンド 
<pre>
pione-client CenterGet.pione -i CenterGetInput/ -b CenterGet
</pre>
 

実行結果 
1VOM.roi, 1VOM-N.roiのファイルが出力されます。 
 
[[mrcImageInfo]]を使って、最大値の座標が中心になっているか確認してみます。 
<pre>
/Advanced1$ mrcImageInfo -I -i CenterGet/output/1VOM.roi
Min: 0 (0, 0, 0)
Max: 3398.12 (19, 19, 24)
Mean: 241.805
SD: 500.988
SE: 1.77126
Sum: 1.93444e+07
/Advanced1$ mrcImageInfo -I -i CenterGet/output/1VOM-N.roi
Min: -1893.8 (0, 4, 33)
Max: 4374.62 (19, 19, 24)
Mean: 157.55
SD: 648.124
SE: 2.29147
Sum: 1.2604e+07
</pre>
最大値を中心に切り出していることが分かります。 
 

==== 補足(ファイルの確認用コマンド) ====
出力したファイルと入力ファイルの違いを見るために後処理を追加します。 
 
作成例 
<pre>
Rule Main
input '*.mrc'.all
output '*.roi'
output '*.tiff'
Flow
rule First
rule Second
rule Final
End

-中略-

Rule Final
input '*.mrc'
input '{$I[1][1]}.roi'
output '{$I[1]}-1.tiff'
output '{$I[2]}-1.tiff'
output '{$I[1]}-2.tiff'
output '{$I[2]}-2.tiff'
Action
mrcImageProjection -i {$I[1]} -o {$I[1]}.2d
mrc2tiff -i {$I[1]}.2d -o {$O[1]}
mrcImageProjection -i {$I[1]} -o {$I[1]}.2d1 -m 1
mrc2tiff -i {$I[1]}.2d1 -o {$O[3]}
mrcImageProjection -i {$I[2]} -o {$I[2]}.2d
mrc2tiff -i {$I[2]}.2d -o {$O[2]}
mrcImageProjection -i {$I[2]} -o {$I[2]}.2d1 -m 1
mrc2tiff -i {$I[2]}.2d1 -o {$O[4]}
End
</pre>
これにより入力ファイル(mrc), 出力ファイル(roi)についてxy平面とyz平面へ投影した画像をtiffファイルで出力します。 
 

出力ファイル 
roiファイル1 
<table>
<tr>
<td>[[画像:Outdata-PIONE-Advanced1-1.png]] 
xy平面 
</td>
<td>[[画像:Outdata1-PIONE-Advanced1-1.png]] 
yz平面 
</td>
</tr>
</table>
 

roiファイル2 
<table>
<tr>
<td>[[画像:Outdata-PIONE-Advanced1-2.png]] 
xy平面 
</td>
<td>[[画像:Outdata1-PIONE-Advanced1-2.png]] 
yz平面 
</td>
</tr>
</table>
 

後処理をしたくないときはMainのoutputとFlow内をコメントアウトするだけです。 
<pre>
Rule Main
input '*.mrc'.all
output '*.roi'
# output '*.tiff'
Flow
rule Initial
rule First
rule Second
# rule Final
End

-後略-

</pre>
 

==== 補足(デフォルトサイズの設定) ====
.parametersなどのファイルがない場合にパラメータ入力で設定したい場合の前処理を追加します。 
 
作成例 
<pre>
Basic Param
$Nx := 40
$Ny := 40
$Nz := 50
End

Rule Main
input '*.mrc'.all
input '*.parameters'
output '*.roi'
output '*.tiff'
Flow
rule Initial
rule First
rule Second
rule Final
End

Rule Initial
input '*.mrc'
output '{$I[1][1]}.parameters'
Action
echo "{$Nx} {$Ny} {$Nz}" > {$O[1]}
End

-後略-

</pre>
このようにすると、.parametersがない場合にはオプション--paramsまたはデフォルト値(40, 40, 50)によってサイズを設定することができます。但し、入力ファイルに.parametersが１つもない場合は動きません。その場合はtouchなどを使用して.parameterを１つは用意する必要があります。 
 

1VOM.parametersのみ下記のように設定してみます。 
<pre>
64 64 64
</pre>
 

Nx=80のみをパラメータとしてコマンド入力してみます。 
<pre>
/Advanced1$ pione-client CenterGet.pione -i ${EOS_HOME}/tutorial/SampleData/ -b CenterGet --params="{Nx:80}"
</pre>

出力ファイル 
1VOM.roiはファイルに従ったサイズになっています。 
<table>
<tr>
<td>[[画像:Outdata-PIONE-Advanced1-3.png]] 
xy平面 
</td>
<td>[[画像:Outdata1-PIONE-Advanced1-3.png]] 
yz平面 
</td>
</tr>
</table>
 

1VOM-N.roiはNxがコマンドの引数、Ny, Nzはデフォルト値のパラメータによるサイズになります。 
<table>
<tr>
<td>[[画像:Outdata-PIONE-Advanced1-4.png]] 
xy平面 
</td>
<td>[[画像:Outdata1-PIONE-Advanced1-4.png]] 
yz平面 
</td>
</tr>
</table>
 

=== 応用２（ウェブページでパラメータを設定しながらコマンドを実行）===
　次は[[#基本８（インタラクティブ操作）]]のようにウェブページの操作を行い、[[Eosのコマンド]]を実行する処理を作ってみましょう。 
 

==== 問題２ ====
2Dファイル([[mrcImage]])を入力ファイルとし、ローパスフィルタ([[mrcImageLowPassFilter]])をウェブページの操作によって実行する次のコマンドを考えます。
*入力ファイルはファイル選択画面から自由に選べるようにし、オプションの値も画面操作で設定できるようにします。
*コマンド実行後は入力ファイルと出力ファイルの画像ファイルをそれぞれ表示して比較できるようにします。
*この画面を見ながら再設定するか、終了するかを選び、終了後に最後の変換ファイルを出力ファイルとして得られるようにします。 
 

-----

　応用問題２：上記の機能を持つパッケージLowPassFilter.ppgを作成してみましょう。

-----
 

==== 解答例 ====
[[PIONE定義書]]、[[html]]ファイル、[[cgi]]ファイルをそれぞれ作成します。 
 

===== [[PIONE定義書]] =====
メイン(Main.pione)の処理を定義します。今回は設定のほとんどをウェブページに委ねるのでここでは出力ファイル名のみ定義しています。 
<pre>
Rule Main
output '*.lpf'.all
Flow
rule Interaction
End

</pre>
 

インタラクティブ(Interaction.pione)の処理を定義します。このファイルは再利用できるように拡張子が付いた全てのファイルを呼び出し元に出力できるようにしています。 
<pre>
Rule Interaction
output '*.*'.all
Action
# build public directory for pione-interactive
mkdir public
cp etc/* public
cp bin/* public

# start interactive operation
pione-interactive browser --public public

cp public/* .
End

</pre>
 
パッケージ用のアノテーション(Annotation.pione)を定義します。 
<pre>
.@ PackageName :: "LowPassFilter"
.@ Editor :: "Kinoshita"
.@ Tag :: "v0.1.0"

</pre>
 

===== [[html]]ファイル =====
Index.htmlはコマンド選択画面にしています。ここから実行したいコマンドを選択します。 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>InteractiveCommand Index Page</title>
</head>
<body>
<a href="mrcImageLowPassFilter.html">mrcImageLowPassFilter</a>
 
 
<a href="?pione-action=finish">終了</a>
</body>
</html>
</pre>
 

mrcImageLowPassFilter.htmlでコマンドや入力ファイルなどのオプションを設定できるようにします。開始ボタンでmrcImageLowPassFilterが実行されます。 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>mrcImageLowPassFilter</title>
</head>
<body>
<form action="mrcImageLowPassFilter.cgi" method="post" enctype="multipart/form-data">
<button type="submit">開始</button>
 
<table>
<tr>
<td>
<input type="file" name="InputFile"/>
</td>
<td>
入力ファイル名(-i)
</td>
</tr>
<tr>
<td>
<input type="text" name="OutputFile" value="outdata.lpf"/>
</td>
<td>
出力ファイル名(-o)
</td>
</tr>
<tr>
<td>
<input type="text" name="HalfValuePoint" value="1.0"/>
</td>
<td>
HalfValuePoint[A-1] (強度を半分に落とす空間周波数を示す)(-hvp)
</td>
</tr>
<tr>
<td>
<input type="text" name="Width" value="1.0"/>
</td>
<td>
空間周波数のcos関数の幅を設定(-w)
</td>
</tr>
<tr>
<td>
<select name="Mode">
<option value="1">1: ステップフィルタ</option>
<option value="2">2: cosフィルタ</option>
<option value="3">3: expフィルタ</option>
<option value="4">4: ガウシアンフィルタ</option>
<option value="5">5: ローレンツ型フィルタ</option>
</select>
</td>
<td>
モード(-m)
</td>
</tr>
</table>
</form>
 
 
<a href="?pione-action=finish">終了</a>
</body>
</html>
</pre>
 

===== [[cgi]]ファイル =====
mrcImageLowPassFilter.cgi 
<pre>
#!/usr/bin/env ruby

require 'cgi'

cgi = CGI.new

### Header
HTMLstr = ""
HTMLstr += "<!DOCTYPE html>"
HTMLstr += "<html>"
HTMLstr += "<head>"
HTMLstr += "<title>mrcImageLowPassFilter</title>"
HTMLstr += "</head>"

HTMLstr += "<body>"

### Close or Back
HTMLstr += '<a href="?pione-action=finish">Close</a>'
HTMLstr += " "
HTMLstr += '<a href="mrcImageLowPassFilter.html">Back</a>'
HTMLstr += " "
HTMLstr += " "

# Main Process

## Query to Parameters

### Copy InputFile
fpQueryInputFile = cgi.params['InputFile'][0]
strInputFile = fpQueryInputFile.original_filename
fpInputFile = open(strInputFile, "wb")
fpInputFile.write(fpQueryInputFile.read)
fpInputFile.close

### Other Query
strOutputFile = cgi['OutputFile']
strHalfValuePoint = cgi['HalfValuePoint']
strWecth = cgi['Width']
strMode = cgi['Mode']

### mrcImageLowPassFilter
command = "mrcImageLowPassFilter"
command += ' -i "' + strInputFile + '"'
command += ' -o "' + strOutputFile + '"'
command += ' -hvp "' + strHalfValuePoint + '"'
command += ' -w "' + strWecth + '"'
command += ' -m "' + strMode + '"'
system(command)

### mrc2gif
#### For input
strGifInputFile = strInputFile + ".gif"
command = "mrc2gif"
command += ' -i "' + strInputFile + '"'
command += ' -o "' + strGifInputFile + '"'
system(command)

#### For output
strGifOutputFile = strOutputFile + ".gif"
command = "mrc2gif"
command += ' -i "' + strOutputFile + '"'
command += ' -o "' + strGifOutputFile + '"'
system(command)

### mrcImageInfo
#### For input
strInfoInputFile = strInputFile + ".info"
command = "mrcImageInfo"
command += ' -I'
command += ' -i "' + strInputFile + '"'
command += ' -o "' + strInfoInputFile + '"'
system(command)

#### For output
strInfoOutputFile = strOutputFile + ".info"
command = "mrcImageInfo"
command += ' -I'
command += ' -i "' + strOutputFile + '"'
command += ' -o "' + strInfoOutputFile + '"'
system(command)

## View as HTML Statement

### Table
HTMLstr += "<table>"

#### Title
HTMLstr += "<tr>"
HTMLstr += "<td>" + strInputFile + "</td>"
HTMLstr += "<td>" + strOutputFile + "</td>"
HTMLstr += "</tr>"

#### GifImage
##### For Input
HTMLstr += "<tr>"
HTMLstr += "<td>"
HTMLstr += '<img src="' + strGifInputFile + '">'
HTMLstr += "</td>"
##### For Output
HTMLstr += "<td>"
HTMLstr += '<img src="' + strGifOutputFile + '">'
HTMLstr += "</td>"
HTMLstr += "</tr>"

#### mrcImageInfo
##### For Input
HTMLstr += "<tr>"
HTMLstr += "<td>"
fpInfoInputFile = open(strInfoInputFile, "r")
fpInfoInputFile.each do |line|
HTMLstr += line + " "
end
fpInfoInputFile.close
HTMLstr += "</td>"
##### For Output
HTMLstr += "<td>"
fpInfoOutputFile = open(strInfoOutputFile, "r")
fpInfoOutputFile.each do |line|
HTMLstr += line + " "
end
fpInfoOutputFile.close
HTMLstr += "</td>"
HTMLstr += "</tr>"

HTMLstr += "</table>"

HTMLstr += "</body>"
HTMLstr += "</html>"

# Output as html
cgi.out(type: "text/html") do
HTMLstr
end

</pre>
htmlヘッダなどの書き込み、クエリを変数やファイルに変換、[[Eosのコマンド]]実行、実行結果をhtml化の順に記述しています。このコードでは[[mrcImageLowPassFilter]]の結果を[[gif]]画像と[[mrcImageInfo]](-I)の情報を表示して比較できるようにしています。 
 

これらのファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Advanced2 こちら]からダウンロードできます。 
 

==== [[パッケージ作成]] ====
コードが完成したら[[パッケージ作成]]を行います。 
<pre>
/PIONE$ pione package build Advanced2
info: update the package info file: local:/Eos/tutorial/SampleCode/PIONE/Advanced2/pione-package.json
info: Package local:/Eos/tutorial/SampleCode/PIONE/LowPassFilter(Kinoshita)+v0.1.0.ppg has been built successfully.
</pre>
 

==== 実行結果 ====
では、動作させてみましょう。 
[[PIONE Webclient]]のジョブページで実行し、Interactionを選択してindexページを開きます。ここでmrcImageLowPassFilterを選択すると設定画面が表示されます。ここでは入力ファイルや設定を変更しながらコマンドの実行を試すことができます。終了やCloseを選択すると、最後に処理を行った結果で出力ファイルが残ります。また、出力ファイル名を変更すると複数のファイルを残すことができます。 
 

[[Media:Input-1VOM-N-2D.mrc|入力ファイル]](2D) 
<table>
<tr>
<td>[[画像:Input-1VOM-N-2D.png]]</td>
<td>最小 
最大 
平均値 
標準偏差 
標準誤差 
</td>
<td>-18651.7 (10, 1, 0) 
52942.7 (24, 39, 0) 
7214.87 
10067.6 
125.845 
</td>
</tr>
</table>
 

<table>
<tr>
<td>実行例1</td>
</tr>
<tr>
<td>[[画像:Outdata-PIONE-Advanced2-1.png|border]]</td>
<td>></td>
<td>[[画像:Outdata1-PIONE-Advanced2-1.png|border]]</td>
</tr>
<tr>
<td>実行例2</td>
</tr>
<tr>
<td>[[画像:Outdata-PIONE-Advanced2-2.png|border]]</td>
<td>></td>
<td>[[画像:Outdata1-PIONE-Advanced2-2.png|border]]</td>
</tr>
<tr>
<td>実行例3</td>
</tr>
<tr>
<td>[[画像:Outdata-PIONE-Advanced2-3.png|border]]</td>
<td>></td>
<td>[[画像:Outdata1-PIONE-Advanced2-3.png|border]]</td>
</tr>
</table>
 

終了後にResult Filesからファイルをダウンロードすると、outputディレクトリにて最後に変換した.lpfファイルを得ることができます。あるいはこの[[PIONE定義書]]に処理を追加して、作成した.lpfファイルを入力ファイルとして使用することもできます。 
 

==== 補足（不要ファイルの削除） ====
今回の処理は操作によって自由にファイルが作成できます。しかし、中には不要なファイルも出てくる場合もあります。そこで、補足処理としてサーバ上のファイルリストを表示し、不要ファイルを削除できるようにしてみましょう。新しく下記のファイルを追加します。なお、pione-action=...については[[インタラクションAPI]]に詳細を記載しています。 
 

/etc/FileDelete.html 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>InteractiveCommand Index Page</title>
</head>
<body>
<a href="index.html">戻る</a> 
<a href="?pione-action=finish">終了</a> 
 
<form action="FileDelete.cgi" method="post" enctype="multipart/form-data">
削除ファイル名 
<input type="text" name="DeleteFile" value=""/>
<button type="submit">削除</button>
</form>
ファイルリスト 
<script src="http://code.jquery.com/jquery-1.11.1.min.js"></script>
<div id="textDiv"></div>
<script type="text/javascript">
var div = document.getElementById("textDiv");
div.textContent = "";
$.getJSON("./", {"pione-action": "list"}, function(data){
$.each(data, function() {
strOut = ".lpf"
if( this.name.indexOf(strOut) + strOut.length == this.name.length ){
div.textContent += this.name +"\n";
}
});
});
</script>
</body>
</html>
</pre>
ファイルリストではpione-action=listによって得たファイルリストの中から最後が.lpfで終わるファイルのみを出力するようにしています。このリストを見ながら削除するファイルをテキストボックスに書き込んで、削除ボタンを押すと削除処理(FileDelete.cgi)が行われます。 
 

/bin/FileDelete.cgi 
<pre>
#!/usr/bin/env ruby

require 'cgi'

cgi = CGI.new

### Header
HTMLstr = ""
HTMLstr += "<!DOCTYPE html>"
HTMLstr += "<html>"
HTMLstr += "<head>"
HTMLstr += "<title>FileDelete</title>"

## Query to Parameters
strDeleteFile = cgi['DeleteFile']

## View as HTML Statement
HTMLstr += '<meta http-equiv="refresh" content="0;URL=./' + strDeleteFile + '?pione-action=delete">'

HTMLstr += "</head>"
HTMLstr += "</html>"

# Output as html
cgi.out(type: "text/html") do
HTMLstr
end
</pre>
ヘッダにてDeleteFileを削除する操作(pione-action=delete)を行っています。 
 

さらに出来上がったページへアクセスするためにindex.htmlのbody内に下記の内容を追加します。 
<pre>
<a href="FileDelete.html">FileDelete</a> 
</pre>
 

これにより不要ファイルの削除を行うことができます。 
[[画像:Outdata-PIONE-Advanced2-4.png|border]] 
上記の例ではOutdata.lpfを削除しています。 
 
[[画像:Outdata-PIONE-Advanced2-5.png|border]] 
削除完了画面が表示されるので、ブラウザのバックボタンで戻ります。 
 
[[画像:Outdata-PIONE-Advanced2-6.png|border]] 
画面表示を更新するとOutdata.lpfが消えていることが確認できます。また、インタラクティブ操作を終了し、ファイルをダウンロードするとOudata.lpfが無いことも確認できます。これにより不要ファイルを削除できたことが分かりました。 
 

=== 応用３（参照像の作成） ===
　今回はループ文を使用した例を示します。 
 

==== 問題３ ====
　入力ファイルを参照用の３次元画像（.ref3d）として、指定した範囲の角度で参照像（.ref2d）を作成する処理を考えます。[[PIONE Webclient]]を利用し、作成した各参照像の画像を確認しながら、ユーザ操作によって適切な角度を決定できるようにします。 
 

-----

　応用問題３：上記の機能を持つパッケージRef3DtoRef2D.ppgを作成してみましょう。

-----
 

==== 解答例 ====
===== [[PIONE定義書]] =====
　ユーザ操作によって３次元画像と投影する角度を設定し、そこから参照像を作成して、結果を画像として確認し、決定かやり直しかを選択できる流れとしています。 
 

Annotation.pione 
<pre>
.@ PackageName :: "Ref3DtoRef2D"
.@ Editor :: "Kinoshita"
.@ Tag :: "v0.2.0"
</pre>
 

Main.pione
<pre>
Rule Main
output '*.ref3d'
output '*.ref2d'
output '*.mon'
output '*.gif'
Flow
rule Start
rule SubMain
rule Result
rule Finish
End

Rule Start
output 'Start0!Flag'
Action
touch {$O[1]}
End

Rule SubMain
input 'Start*!Flag'
output '*.*'.all
Flow
rule Interaction {val : '{$I[1][1]}'.str().i()}
rule Ref3DtoRef2D {val : '{$I[1][1]}'.str().i()}
End

Rule Finish
input 'Finish*!Flag'
input '*.*-{$I[1][1]}'
output '{$I[2][1]}.{$I[2][2]}'
Action
cp {$I[2]} {$O[1]}
End
</pre>
SubMainルールにて角度と３次元画像の設定とその２次元画像の作成を実行します。このルールはStartN!Flagで発火し、最初はStartルールで、やり直すときはResultルールでそれぞれStartN!Flagを作成します。このときのNはやり直しのために設定した整数で、前に作成されたファイルとこれから作成するファイルが混ざらないようにするために設定しています。ルールFinishで決定したときのファイルのみを取り出します。 
 

Interaction.pione 
<pre>
Rule Interaction
input 'Start{$val}!Flag'
output '*.*'.all
param $val
Action
# build public directory for pione-interactive
mkdir public
cp etc/* public
cp bin/* public

# start interactive operation
pione-interactive browser --public public

cp public/* .
for file in $(ls *Mode *Rot1 *Rot2 *Rot3 *.ref3d) ;
do
mv "$file" "$file-{$val}";
done
End
</pre>
やり直しに対応できるように処理の最後で作成されたファイルに番号を付けています。 
 

Ref3DtoRef2D.pione 
<pre>
Rule Ref3DtoRef2D
input '*!*!*.!Rot1-{$val}'
input '*!*!*.!Rot2-{$val}'
input '*!*!*.!Rot3-{$val}'
input '*.!Mode-{$val}'
input '*.ref3d-{$val}'
output '*.ref2d-{$val}'.all
output 'Ref3DtoRef2D.info-{$val}'
$min1 := '{$I[1][1]}'.str().f()
$max1 := '{$I[1][2]}'.str().f()
$delta1 := '{$I[1][3]}'.str().f()
$loop1 := (($max1 - $min1) / $delta1).i()
$min2 := '{$I[2][1]}'.str().f()
$max2 := '{$I[2][2]}'.str().f()
$delta2 := '{$I[2][3]}'.str().f()
$loop2 := (($max2 - $min2) / $delta2).i()
$min3 := '{$I[3][1]}'.str().f()
$max3 := '{$I[3][2]}'.str().f()
$delta3 := '{$I[3][3]}'.str().f()
$loop3 := (($max3 - $min3) / $delta3).i()
$mode := '{$I[4][1]}'.str()
param $val
Flow
rule One3Dto2D {rot1: $min1 + ((0.upto($loop1)).f() * $delta1), rot2: $min2 + ((0.upto($loop2)).f() * $delta2), rot3: $min3 + ((0.upto($loop3)).f() * $delta3), mode : $mode, val : $val}
rule Info3Dto2D {val : $val}
End

Rule Info3Dto2D
input '*.ref2d-{$val}'.all
output 'Ref3DtoRef2D.info-{$val}'
param $val
Action
for file in $(ls *.ref2d-{$val})
do
echo "./$file" >> {$O[1]}
done
End

Rule One3Dto2D
input '*.ref3d-{$val}'
output '*.ref2d-{$val}'.all
param $rot1
param $rot2
param $rot3
param $mode
param $val
Action
output="{$I[1][1]}-{$mode}-{$rot1}-{$rot2}-{$rot3}.ref2d-{$val}"
mrc3Dto2D -i {$I[1]} -o $output \
-Rot1 {$rot1} {$rot1} 1 \
-Rot2 {$rot2} {$rot2} 1 \
-Rot3 {$rot3} {$rot3} 1 \
-EulerMode {$mode};
End
</pre>
ルールRef3DtoRef2Dは大きくFlowLoop3Dto2D1とOne3Dto2Dの２つのルールに分かれます。ここでもやり直しに対応するためにファイルの末尾に番号を付けます。ルールInfo3Dto2Dでは画像作成のために２次元画像の一覧を作成します。ルールOne3Dto2D1ではuptoによるループを利用して３次元画像から[[mrc3Dto2D]]によって２次元画像を次々に作成します。このとき３軸毎に回転角度をそれぞれuptoで設定しています。 
 

Result.pione 
<pre>
Rule Result
input 'Ref3DtoRef2D.info-*'
input '*.ref2d-{$I[1][1]}'.all
output '*!Flag'
output 'Ref3DtoRef2D.mon-{$I[1][1]}'
output 'Ref3DtoRef2D.gif-{$I[1][1]}'
Flow
rule Ref2DtoGIF {val : '{$I[1][1]}'.str().i()}
rule ResultCheck {val : '{$I[1][1]}'.str().i()}
End

Rule Ref2DtoGIF
input 'Ref3DtoRef2D.info-{$val}'
input '*.ref2d-{$val}'.all
output 'Ref3DtoRef2D.mon-{$val}'
output 'Ref3DtoRef2D.gif-{$val}'
param $val
Action
mrcImageMontageCreate -i {$I[1]} -o {$O[1]}
mrc2gif -i {$O[1]} -o {$O[2]}
End

Rule ResultCheck
input 'Ref3DtoRef2D.gif-{$val}'
output '*!Flag'
param $val
Action
# build public directory for pione-interactive
mkdir public
cp etc/index2.html public/index.html
cp bin/* public
cp {$I[1]} public/Ref3DtoRef2D.gif

# start interactive operation
pione-interactive browser --public public

cp public/* .
if [ -e "Finish!Flag" ]; then
mv "Finish!Flag" "Finish{$val}!Flag";
elif [ -e "Start!Flag" ]; then
mv "Start!Flag" "Start{$val + 1}!Flag";
fi
End
</pre>
ルールResultはRef2DtoGIFとResultCheckに分かれます。ルールRef2DtoGIFでは各２次元像をひとまとめにしたgif画像を作成します。ルールResultCheckではgif画像をindex2.htmlのページに表示して、ユーザ操作にて決定のときはFinishN!Flagをやり直しのときはStartN!Flagを作成するようにしています。 
 

===== [[html]]ファイル =====
index.html 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>InteractiveCommand Index Page</title>
</head>
<body>
<a href="Ref3DtoRef2D.html">Ref3DtoRef2D</a> 
 
<a href="?pione-action=finish">終了</a>
</body>
</html>
</pre>
 

Ref3DtoRef2D.html 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Ref3DtoRef2D</title>
</head>
<body>
<form action="Ref3DtoRef2D.cgi" method="post" enctype="multipart/form-data">
<button type="submit">開始</button>
 
<table>
<tr>
<td>
<input type="file" name="InputFile"/>
</td>
<td>
入力ファイル名(.ref3d)
</td>
</tr>
<tr>
<td>
<select name="Mode1">
<option value="X">X</option>
<option value="Y">Y</option>
<option value="Z">Z</option>
</select>
<select name="Mode2">
<option value="O">O</option>
<option value="E">E</option>
</select>
<select name="Mode3">
<option value="Y">Y</option>
<option value="N">N</option>
</select>
<select name="Mode4">
<option value="S">S</option>
<option value="R">R</option>
</select>
</td>
<td>
回転モード
</td>
</tr>
</table>
<table>
<tr>
<td>

</td>
<td>
最小値
</td>
<td>
最大値
</td>
<td>
加算値
</td>
</tr>
<tr>
<td>
角度１
</td>
<td>
<input type="text" name="RotMin1" value="0"/>
</td>
<td>
<input type="text" name="RotMax1" value="359"/>
</td>
<td>
<input type="text" name="RotDelta1" value="30"/>
</td>
</tr>
<tr>
<td>
角度２
</td>
<td>
<input type="text" name="RotMin2" value="0"/>
</td>
<td>
<input type="text" name="RotMax2" value="359"/>
</td>
<td>
<input type="text" name="RotDelta2" value="30"/>
</td>
</tr>
<tr>
<td>
角度３
</td>
<td>
<input type="text" name="RotMin3" value="0"/>
</td>
<td>
<input type="text" name="RotMax3" value="0"/>
</td>
<td>
<input type="text" name="RotDelta3" value="30"/>
</td>
</tr>
</table>
</form>
 
 
<a href="index.html">戻る</a> 
<a href="?pione-action=finish">終了</a> 
</body>
</html>
</pre>
このページでは入力ファイルと回転モードと及び各角度毎の最小値、最大値、加算値を設定して実行できるようにしています。 
 

index2.html 
<pre>
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>InteractiveCommand Index Page</title>
</head>
<body>
<img src="Ref3DtoRef2D.gif"> 
 
<form action="Result.cgi" method="post" enctype="multipart/form-data">
<button type="submit">決定</button> 
<input type="hidden" name="Result" value="Finish"/>
</form>
<form action="Result.cgi" method="post" enctype="multipart/form-data">
<button type="submit">やり直し</button> 
<input type="hidden" name="Result" value="Start"/>
</form>
</body>
</html>
</pre>
これはルールResultのときに画像を確認しながら、決定かやり直しかを選択するためのページです。 
 

===== [[cgi]]ファイル =====
Ref3DtoRef2D.cgi 
<pre>
#!/usr/bin/env ruby

require 'cgi'

cgi = CGI.new

### Header
strHTML = ""
strHTML += "<!DOCTYPE html>"
strHTML += "<html>"
strHTML += "<head>"
strHTML += "<title>Ref3DtoRef2D</title>"
### Auto Close
strHTML += '<meta http-equiv="REFRESH" content="0;URL=?pione-action=finish">'

# Main Process

## Query to Parameters

### Copy InputFile
fpQueryInputFile = cgi.params['InputFile'][0]
strInputFile = fpQueryInputFile.original_filename
fpInputFile = open(strInputFile, "wb")
fpInputFile.write(fpQueryInputFile.read)
fpInputFile.close

### Other Query
strMode = cgi['Mode1'] + cgi['Mode2'] + cgi['Mode3'] + cgi['Mode4']
strRotMin1 = cgi['RotMin1']
strRotMax1 = cgi['RotMax1']
strRotDelta1 = cgi['RotDelta1']
strRotMin2 = cgi['RotMin2']
strRotMax2 = cgi['RotMax2']
strRotDelta2 = cgi['RotDelta2']
strRotMin3 = cgi['RotMin3']
strRotMax3 = cgi['RotMax3']
strRotDelta3 = cgi['RotDelta3']

### Set Parameter to FileNames
strParamFile = strMode + ".!Mode"
command = "touch " + strParamFile
system(command)

strParamFile = strRotMin1 + "!" + strRotMax1 + "!" + strRotDelta1 + ".!Rot1"
command = "touch " + strParamFile
system(command)

strParamFile = strRotMin2 + "!" + strRotMax2 + "!" + strRotDelta2 + ".!Rot2"
command = "touch " + strParamFile
system(command)

strParamFile = strRotMin3 + "!" + strRotMax3 + "!" + strRotDelta3 + ".!Rot3"
command = "touch " + strParamFile
system(command)

command = "cp " + strInputFile + " Refer.ref3d"
system(command)

strHTML += "</head>"
strHTML += "</html>"

# Output as html
cgi.out(type: "text/html") do
strHTML
end
</pre>
Ref3DtoRef2D.htmlで設定したデータをファイルに保存します。処理後は自動的にインタラクティブ操作を終了し、以降は[[PIONE]]にてルールRef3DtoRef2Dを実行します。 
 

<pre>
#!/usr/bin/env ruby

require 'cgi'

cgi = CGI.new

### Header
strHTML = ""
strHTML += "<!DOCTYPE html>"
strHTML += "<html>"
strHTML += "<head>"
strHTML += "<title>Result</title>"
### Auto Close
strHTML += '<meta http-equiv="REFRESH" content="0;URL=?pione-action=finish">'

# Main Process
## Query to Parameters
Result = cgi['Result']

command = "touch " + Result + "!Flag"
system(command)

strHTML += "</head>"
strHTML += "</html>"

# Output as html
cgi.out(type: "text/html") do
strHTML
end
</pre>
index2.htmlの操作によって、決定またはやり直しを選択したときの処理です。決定のときはFinish!Flag、やり直しのときはStart!FLagを作成します。処理後は自動的にインタラクティブ操作を終了します。 
 

これらのファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Advanced3 こちら]からダウンロードできます。 
 

==== [[パッケージ作成]] ====
コードが完成したら[[パッケージ作成]]を行います。 
<pre>
/PIONE$ pione package build Advanced3
info: update the package info file: local:/Eos/tutorial/SampleCode/PIONE/Advanced3/pione-package.json
info: Package local:/Eos/tutorial/SampleCode/PIONE/Ref3DtoRef2D(Kinoshita)+v0.1.1.ppg has been built successfully.
</pre>
 

==== 実行結果 ====
では、動作させてみましょう。 
[[PIONE Webclient]]のジョブページで実行し、Interactionを選択してindexページを開きます。ここでRef3DtoRef2Dを選択すると設定画面が表示されます。 

今回は[[Media:1VOM.mrc|下記の入力ファイル]]を３次元像として２次元画像を作成してみます。 
<table>
<tr>
<td>[[画像:Input-1VOM.png]] 
xy平面 
</td>
<td>[[画像:Input1-1VOM.png]] 
yz平面 
</td>
<td>最小 
最大 
平均値 
標準偏差 
標準誤差 
</td>
<td>0 (0, 0, 0) 
3398.12 (23, 55, 41) 
72.129 
294.805 
0.368507 
</td>
</tr>
</table>
 

[[画像:Outdata-PIONE-Advanced3-1.png|border]] 
入力ファイル及び回転のモード（参照: [[オイラー角]]）、角度の範囲を設定して開始ボタンを押します。 
 

[[画像:Outdata-PIONE-Advanced3-2.png|border]] 
すると、上記のようにインタラクティブ操作は完了して、再び[[PIONE]]にて２次元像の作成処理が動きます。（このページは閉じて構いません） 
 

[[画像:Outdata-PIONE-Advanced3-3.png|border]] 
再びInteractionボタンが赤色になりますので、開くと作成された２次元像の一覧が画像にて表示されます。この内容を見ながら「決定」か「やり直し」を選択します。 
 

[[画像:Outdata-PIONE-Advanced3-2.png|border]] 
同様にインタラクティブ操作が完了しますので、ページを閉じます。 
 

[[画像:Outdata-PIONE-Advanced3-4.png|border]] 
「やり直し」を選択すると、再度設定画面を開くことができます。また、「決定」を選択するとこのときの結果がouputへ出力されます。このようにして結果を確認しながら適切な設定を選び直すことが出来ます。 
 

上記の設定で決定したときのgif画像（縮小表示） 
[[画像:Outdata-PIONE-Advanced3-5.gif|500px]] 
 

==== 補足（チケットを使ってルールを制御する） ====
設定、処理、確認のルールが同時に動いてはそれぞれの役割が満たせませんので、チケットを使用して制御を加えてみましょう。もちろん入力ファイルや出力ファイルの関係がうまく作れていれば同時に動くことはありません。今回は念のための処置として作成します。 
 

Main.pione 
<pre>
Rule Main
output '*.ref3d'
output '*.ref2d'
output '*.mon'
output '*.gif'
Flow
rule Start >>> SubMain >>> Result
rule Finish
End

Rule Start
output 'Start0!Flag'
Action
touch {$O[1]}
End

Rule SubMain
input 'Start*!Flag'
output '*.*'.all
Flow
rule Interaction {val : '{$I[1][1]}'.str().i()} >>> Ref3DtoRef2D {val : '{$I[1][1]}'.str().i()}
End

Rule Finish
input 'Finish*!Flag'
input '*.*-{$I[1][1]}'
output '{$I[2][1]}.{$I[2][2]}'
Action
cp {$I[2]} {$O[1]}
End
</pre>
MainルールとSubMainルールにて順番を指定しています。 
このファイルは[https://sourceforge.jp/projects/eos/scm/git/tutorial/archive/master/SampleCode/PIONE/Advanced3plus1 こちら]からダウンロードできます。 
 

=== 応用４（単粒子解析） ===
　次は[[Makefile]]をベースとして[[単粒子解析]]のための処理を作ってみましょう。 
 

==== 問題４ ====
元のMakefileが下記であったとします。 
<pre>
.SUFFIXES: .roi .smooth .shrink .pad .fit .corinfo .3dinfo .3dwholeinfo .3d4sinfo .lst .3dlst .padlst .3d .ds6 .3dwholelst .3dwhole .wholeds6 .3d4s .4sds6 .3d4sinfolst

#SHELL=/bin/bash

REFERENCE=1J4Z-move-shrink.stack

.lst.padlst:
rm -f $*.padlst
for i in `cat $*.lst`; do \
FILENAME=`basename $$i .roi`; \
echo $$FILENAME; \
make $$FILENAME.pad ; \
echo $$FILENAME.pad >> $*.padlst; \
done

.padlst.3dlst:
rm -f $*.3dlst
rm -f $*.3dwholelst
for i in `cat $*.padlst`; do \
FILENAME=`basename $$i .pad`; \
make $$FILENAME.fit ; \
make $$FILENAME.3dinfo ; \
cat $$FILENAME.3dinfo >> $*.3dlst ; \
make $$FILENAME.3dwholeinfo ; \
cat $$FILENAME.3dwholeinfo >> $*.3dwholelst ; \
done

.padlst.3d4sinfolst:
rm -f $*.3d4sinfolst
for i in `cat $*.padlst`; do \
FILENAME=`basename $$i .pad`; \
make $$FILENAME.3d4sinfo ; \
cat $$FILENAME.3d4sinfo >> $*.3d4sinfolst ; \
done

.roi.smooth:
mrcImageSmoothing -i $*.roi -o $*.smooth -m 1 -r 4

.smooth.shrink:
mrcImageShrink -i $*.smooth -o $*.shrink -S 8

.shrink.pad:
mrcImagePad -i $*.shrink -o $*.pad -W 32 -H 32

.pad.fit:
mrcImageAutoRotationCorrelation -i $*.pad -r $(REFERENCE) -fit $*.fit -O $*.corinfo -n 72 -m 18 -nRot1 72 -nRot2 72 -nRot3 1 > /dev/null

.fit.3dinfo:
awk '/Cor/ { print $$18,$$16,$$2,$$3,$$4,"0.0"}' $*.corinfo | sort -r | sed -e s/pad/fit/ > $*.3dinfolst
head -n 1 $*.3dinfolst | awk ' {print $$2,$$3,$$4,$$5,$$6,$$1'} > $*.3dinfo

.fit.3dwholeinfo:
awk '/Cor/ { print $$18,$$16,$$2,$$3,$$4,$$9,$$11,$$12}' $*.corinfo | sort -r | sed -e s/pad/shift/ > $*.3dwholeinfolst
head -n 1 $*.3dwholeinfolst | awk ' {print $$2,$$3,$$4,$$5,$$6,$$7,$$8,$$1'} > $*.3dwholeinfo
X=`awk '{print -8*$$6; }' $*.3dwholeinfo`; \
Y=`awk '{print -8*$$7; }' $*.3dwholeinfo`; \
echo $$X,$$Y; mrcImageShift -i $*.roi -o $*.shift -x $$X -y $$Y -z 0

.3dlst.3d:
mrc2Dto3D -I $*.3dlst -o $*.3d -InterpolationMode 2 -Double -DoubleCounter $*.3dcounter -CounterThreshold 0.5 -m 1 -WeightMode 6

.3d.ds6:
mrc2map -i $*.3d -o $*.ds6 -m 3

.3dwholelst.3dwhole:
mrc2Dto3D -I $*.3dwholelst -o $*.3dwhole -InterpolationMode 2 -Double -DoubleCounter $*.3dwholecounter -CounterThreshold 0.5 -m 1 -WeightMode 6
.3dwhole.wholeds6:
mrc2map -i $*.3dwhole -o $*.wholeds6 -m 3
ln -sf $*.wholeds6 $*.whole.ds6

.fit.3d4sinfo:
awk '/Cor/ { print $$18,$$16,$$2,$$3,$$4,$$9,$$11,$$12}' $*.corinfo | sort -r | sed -e s/pad/shift/ > $*.3d4sinfolst
head -n 1 $*.3d4sinfolst | awk ' {print $$2,$$3,$$4,$$5,$$6,$$7,$$8,$$1'} > $*.3d4sinfo
X=`awk '{print -4*$$6; }' $*.3d4sinfo`; \
Y=`awk '{print -4*$$7; }' $*.3d4sinfo`; \
echo $$X,$$Y;
mrcImageShrink -i $*.roi -o $*.4shrink -S 4
mrcImagePad -i $*.4shrink -o $*.pad -W 64 -H 64
mrcImageShift -i $*.roi -o $*.4shift -x $$X -y $$Y -z 0

.3d4sinfolst.3d4s:
mrc2Dto3D -I $*.3d4sinfolst -o $*.3d4s -InterpolationMode 2 -Double -DoubleCounter $*.3d4scounter -CounterThreshold 0.5 -m 1 -WeightMode 6
.3d4s.4sds6:
mrc2map -i $*.3d4s -o $*.4sds6 -m 3
ln -sf $*.4sds6 $*.4s.ds6
</pre>
上記のMakefileは複数の電子顕微鏡画像(.roi)に対して、参照像を使って角度決定をした後に３次元再構成を実行する処理となっています。.roiファイルの一覧は.lstに書かれていて、参照像の2Dスタック(REFERENCEで設定)があることが前提となっています。このmakefileは相関マップ(.corinfo)を作成するときに1/8とした画像を使用することで速度の向上をはかっています。"make （.lstのファイル名）.3d"で1/8サイズ、"make （.lstのファイル名）.3dwhole"で1/1サイズ、"make （.lstのファイル名）.3d4s"で1/4サイズの３次元像が作成されます。 
 

-----

　応用問題４：上記の機能を持つパッケージSingleParticle_3DReconstruction.ppgを作成してみましょう。

-----
 

==== 解答例１ ====
解答例を一部示します。全体は[[Media:PIONE-Advanced4-1.zip|こちら]]をご覧下さい。元の機能に加えて、サンプルの.roiファイルと参照像2Dスタック.stackを作成できるようにしています。この場合の入力ファイルは.mrcのみです。さらに、作成された３次元像を画像としてすぐに確認できるように３方向からの投影像を[[gif]]ファイルで出力しています。また、機能毎にフラグを設けて作成したいデータのみを作成できるようにしています。 
 

===== 実装 =====
Main.pione 
<pre>
Rule Main
if $Flag_ROI or $Flag_Ref
input '*.mrc'
end

if $Flag_ROI.not()
input '*.lst'
input '*.roi'.all
end

if $Flag_Ref.not()
input '*.stack'
end

if $Flag_3D
output '{$I[1][1]}.3dlst'
output '{$I[1][1]}.3d'
output '{$I[1][1]}.ds6'
end

if $Flag_3DWhole
output '{$I[1][1]}.3dwholelst'
output '{$I[1][1]}.3dwhole'
output '{$I[1][1]}.wholeds6'
output '{$I[1][1]}.whole.ds6'
end

if $Flag_3D4S
output '{$I[1][1]}.3d4slst'
output '{$I[1][1]}.3d4s'
output '{$I[1][1]}.4sds6'
output '{$I[1][1]}.4s.ds6'
end

if $Flag_ROI
output '*.tiff'.all
end

output '*.gif'.all

Flow

if $Flag_ROI
rule Create_SampleROI
end

if $Flag_Ref
rule Create_stack
end

rule Preprocess
rule Create_fit

if $Flag_3D
rule Create_3dlst
rule Create_3d
end

if $Flag_3DWhole
rule Create_3dwholelst
rule Create_3dwhole
end

if $Flag_3D4S
rule Create_3d4slst
rule Create_3d4s
end

rule Projection_3d
End
</pre>
 

Main.pione内で使用しているルールは下記のようにMakefileの処理と対応しています。 
<table border="1">
<tr>
<th>Main.pione内のルール</th>
<th>サブルール</th>
<th>Makefile</th>
<th>説明</th>
</tr>
<tr>
<td>Create_SampleROI</td>
<td>-</td>
<td>なし</td>
<td>サンプル用の.roiファイルを複数作成</td>
</tr>
<tr>
<td>Create_stack</td>
<td>-</td>
<td>なし</td>
<td>参照像の2Dスタック.stackファイルを作成</td>
</tr>
<tr>
<td>Preprocess</td>
<td>pad_padlst 
roi_smooth 
smooth_shrink 
shrink_pad 
</td>
<td>.lst.padlst 
.roi.smooth 
.smooth.shrink 
.shrink.pad 
</td>
<td>.padファイル一覧を作成 
.roiの平滑化して.smoothを作成 
.smoothを縮小して.shrinkを作成 
.shrinkを参照画像と同じサイズにパディングして.padを作成 
</td>
</tr>
<tr>
<td>Create_fit</td>
<td>-</td>
<td>.pad.fit</td>
<td>.padから.stackを使って相関マップ.corinfoを作成（最も近い画像.fitも作成）</td>
</tr>
<tr>
<td>Create_3dlst</td>
<td>fit_3dinfo 
Sum_3dinfo_3dlst</td>
<td>.fit.3dinfo</td>
<td>各相関マップ.corinfoから相関値が最大の角度を集めてリスト.3dlstを作成</td>
</tr>
<tr>
<td>Create_3d</td>
<td>Reconstruct_3dlst_3d 
Convert_3d_ds6</td>
<td>.3dlst.3d 
.3d.ds6</td>
<td>リスト.3dlstと.fitを使って３次元像.3d及び.ds6を作成（1/8サイズ）</td>
</tr>
<tr>
<td>Create_3dwholelst</td>
<td>fit_3dwholeinfo 
Sum_3dwholeinfo_3dwholelst</td>
<td>.fit.3dwholeinfo</td>
<td>Create_3dlstの1/1サイズバージョン</td>
</tr>
<tr>
<td>Create_3dwhole</td>
<td>Reconstruct_3dwholelst_3dwhole 
Convert_3dwhole_wholeds6</td>
<td>.3dwholelst.3dwhole 
.3dwhole.wholeds6</td>
<td>Create_3dの1/1サイズバージョン</td>
</tr>
<tr>
<td>Create_3d4slst</td>
<td>fit_3d4sinfo 
Sum_3d4sinfo_3d4slst</td>
<td>.fit.3d4sinfo</td>
<td>Create_3dlstの1/4サイズバージョン</td>
</tr>
<tr>
<td>Create_3d4s</td>
<td>Reconstruct_3d4slst_3d4s 
Convert_3d4s_4sds6</td>
<td>.3d4sinfolst.3d4s 
.3d4s.4sds6</td>
<td>Create_3dの1/4サイズバージョン</td>
</tr>
<tr>
<td>Projection_3d</td>
<td>-</td>
<td>なし</td>
<td>作成された３次元像.3dなどを3方向から投影したgif画像を作成</td>
</tr>
</table>
 

また、下記のように画像サイズや回転方法をパラメータにて設定できるようにしています。 
 

Parameter.pione 
<pre>
# basic param
## For Size
param $X_SIZE := 80
param $Y_SIZE := 80
param $SHRINK := 8
param $SHRINK4S := 4

## For AutoRotationCorrelation
param $N_ROT := 72
param $N_ROT1 := 72
param $N_ROT2 := 72
param $N_ROT3 := 1

## For RefData
param $REF_ROT_MODE := "XOYS"
param $REF_ROT1_START := 0
param $REF_ROT1_END := 359
param $REF_ROT1_DELTA := 15
param $REF_ROT2_START := 0
param $REF_ROT2_END := 359
param $REF_ROT2_DELTA := 15
param $REF_ROT3_START := 0
param $REF_ROT3_END := 0
param $REF_ROT3_DELTA := 15

## For SampleROI
param $ROI_ROT_MODE := "XOYS"
param $ROI_ROT1_START := 0
param $ROI_ROT1_END := 359
param $ROI_ROT1_DELTA := 30
param $ROI_ROT2_START := 0
param $ROI_ROT2_END := 359
param $ROI_ROT2_DELTA := 30
param $ROI_ROT3_START := 0
param $ROI_ROT3_END := 0
param $ROI_ROT3_DELTA := 30
param $ROI_SN := 1

# advanced param
advanced param $Flag_ROI := true
advanced param $Flag_Ref := true
advanced param $Flag_3D := true
advanced param $Flag_3DWhole := true
advanced param $Flag_3D4S := true
</pre>
 

===== Makefile との動作比較 =====
作成した[[PIONE定義書]]と元の[[Makefile]]との処理時間を比較して、ここまでの実装の効果があったかを検証します。今回は.3dファイルの作成に関して比較します。 
 

.roiファイルと.stackファイルは予めParameter.pioneを下記のようにして作成しています。（[[ROI]]画像: サイズ256×256, 2つの角度0 ~ 300: 60刻み） 
<pre>
param $X_SIZE := 256 #80
param $Y_SIZE := 256 #80

param $ROI_ROT1_START := 0
param $ROI_ROT1_END := 359
param $ROI_ROT1_DELTA := 60 #30

param $ROI_ROT2_START := 0
param $ROI_ROT2_END := 359
param $ROI_ROT2_DELTA := 60 #30

param $ROI_ROT3_START := 0
param $ROI_ROT3_END := 0
param $ROI_ROT3_DELTA := 30

advanced param $Flag_ROI := true
advanced param $Flag_Ref := true
advanced param $Flag_3D := false
advanced param $Flag_3DWhole := false
advanced param $Flag_3D4S := false
</pre>
 

[[Media:1VOM.mrc|.roiや.stack作成で使用する.mrcファイル]] 
<table>
<tr>
<td>[[画像:Input-1VOM.png]] 
xy平面 
</td>
<td>[[画像:Input1-1VOM.png]] 
yz平面 
</td>
<td>最小 
最大 
平均値 
標準偏差 
標準誤差 
</td>
<td>0 (0, 0, 0) 
3398.12 (23, 55, 41) 
72.129 
294.805 
0.368507 
</td>
</tr>
</table>
 

作成された[[ROI]]ファイルの一覧をData.lstに書き込んで[[Makefile]]で動作できるようにします。また、Makefile内にてREFERENCEを作成した.stackファイル名に変更します。 
<pre>
#REFERENCE=1J4Z-move-shrink.stack
REFERENCE=1WDC.stack
</pre>
以上の.roiファイル、.stackファイル、Makefileを入力用のディレクトリに置きます。 
 

Makefileの処理時間の下記の[[PIONE定義書]]を作って、計測しています。 
計測①コード 
<pre>
Rule Main
input '*.lst'
input '*.roi'.all
input 'Makefile'
input '*.stack'.all
output '{$I[1][1]}.ds6'
Action
make {$O[1]}
End
</pre>
上記のルールの場合、（全体の処理）＝（Makefile処理）＋（入力ファイル処理）＋（出力ファイル処理）となっているので、下記の計測②時間との差分を算出すれば、およそのMakefileの処理時間が算出できます。 
 

計測②コード 
<pre>
Rule Main
input '*.lst'
input '*.roi'.all
input 'Makefile'
input '*.stack'.all
input '*.ds6'
output '{$I[5][1]}.ds6out'
Action
cp {$I[5]} {$O[1]}
End
</pre>
 

計測①結果（９分強） 
[[画像:Outdata-PIONE-Advanced4-12.png]] 
 

計測②結果（１秒程度） 
[[画像:Outdata-PIONE-Advanced4-13.png]] 
 

計測①が９分強、計測②が１秒程度なので、Makefileの処理時間は９分強掛かったことが分かりました。 
 

では、[[:Media:PIONE-Advanced4-1.zip|今回実装した処理]]をタスク数２（-t 2）で実行してみます。 
 

-t 2の結果（７分程度） 
[[画像:Outdata-PIONE-Advanced4-16.png]] 
今回の実装においては２分程度の削減で、処理時間がMakefileの7/9となりました。しかし、この実装においてルールを細かく分けすぎているためにルール間の入出力ファイルのやり取りによる処理が各所で発生しています。次の項目にてこれらの無駄を省くためのコーディングを考えて、さらに時間を削減してみましょう。 
 

==== 速度アップのための実装 ====
===== リスト作成の省略 =====
まずは.lstなどを作成している部分について考えます。[[PIONE]]は１：複数の処理が可能ですのでリストの作成は省略できます。 
 

Main.pione 
<pre>
Rule Main
if ($Mode_ROI + $Mode_Ref) != 0
input '*.mrc'
end

if $Mode_Ref == 0
input '*.stack'
end

if $Mode_ROI == 0
input '*.roi'.all
end

if $Flag_3D
output '{$I[1][1]}.3dlst'
output '{$I[1][1]}.3d'
output '{$I[1][1]}.ds6'
end

if $Flag_3DWhole
output '{$I[1][1]}.3dwholelst'
output '{$I[1][1]}.3dwhole'
output '{$I[1][1]}.wholeds6'
output '{$I[1][1]}.whole.ds6'
end

if $Flag_3D4S
output '{$I[1][1]}.3d4slst'
output '{$I[1][1]}.3d4s'
output '{$I[1][1]}.4sds6'
output '{$I[1][1]}.4s.ds6'
end

if $Mode_ROI != 0
output '*.tiff'.all
end

if $Flag_Projection
output '*.gif'.all
end
Flow
case $Mode_ROI
when 1
rule Create_Sample3d
rule Create_SampleROI_each {rot1: (0.upto($roi_rot1_loop))*$ROI_ROT1_DELTA, rot2: (0.upto($roi_rot2_loop))*$ROI_ROT2_DELTA, rot3: (0.upto($roi_rot3_loop))*$ROI_ROT3_DELTA}
when 2
rule Create_Sample3d
rule Create_SampleROI_all
end

if $Mode_Ref != 0
rule Create_stack
end

rule Preprocess

case $Mode_Cor
when 1
rule Create_fit_each
when 2
rule Create_fit_all
end

if $Flag_3D
rule Create_3dlst {filename: $I[1][1].str()}
rule Create_3d
end

if $Flag_3DWhole
rule Create_3dwholelst {filename: $I[1][1].str()}
rule Create_3dwhole
end

if $Flag_3D4S
rule Create_3d4slst {filename: $I[1][1].str()}
rule Create_3d4s
end

if $Flag_Projection
rule Projection_3d
end
End
</pre>
.roiファイル、.padファイルの一覧を記述した.lstファイル.padlstファイルを廃止して、入力用ディレクトリにある全ての.roiファイルについて処理を行うように変更しました。（但し、.3dlstなどは角度情報として使用するのでそのまま）また、入力ファイル１つに対して複数のファイルを作成する箇所についてeachで行うかallで行うかをパラメータによって決められるようにしています。今回の場合はeachを使用して複数のタスクで実行すると速度の改善が期待できます。（参照：[[#基本４の補足（eachでの速度検証）]]） 
 

allで実行した場合（約65秒） 
[[画像:Outdata-PIONE-Advanced4-7.png|1120px]] 
 

eachで実行した場合（約81秒）（allよりも時間が掛かっている） 
[[画像:Outdata-PIONE-Advanced4-8.png|1390px]] 
 

eachを-t 2で実行した場合（約47秒）（速度が改善されている） 
[[画像:Outdata-PIONE-Advanced4-9.png|820px]] 
 

eachを-t 3で実行した場合（約36秒）（さらに速度が改善されている） 
[[画像:Outdata-PIONE-Advanced4-10.png|635px]] 
 

eachを-t 4で実行した場合（約31秒）（若干速度が改善されている） 
[[画像:Outdata-PIONE-Advanced4-11.png|550px]] 
 

上記は１つのマシンにおいてallと複数のタスクによるeachの速度の違いです。eachを複数のタスクで動作させると、allの場合よりも速く処理できることが分かります。そして、タスク数が多いほどが速度が改善されています。しかし、タスク数を増やす毎に改善の度合いは緩やかになっています。マシン毎で一度に処理できるタスク数を把握し、全てのタスクをいくつに分けるかを考えると良いでしょう。 
 

Param.pione 
<pre>
# basic param
## For Size
param $X_SIZE := 80
param $Y_SIZE := 80
param $SHRINK := 8
param $SHRINK4S := 4

## For AutoRotationCorrelation
param $N_ROT := 72
param $N_ROT1 := 72
param $N_ROT2 := 72
param $N_ROT3 := 1

## For RefData
param $REF_ROT_MODE := "XOYS"
param $REF_ROT1_START := 0
param $REF_ROT1_END := 359
param $REF_ROT1_DELTA := 15
param $REF_ROT2_START := 0
param $REF_ROT2_END := 359
param $REF_ROT2_DELTA := 15
param $REF_ROT3_START := 0
param $REF_ROT3_END := 0
param $REF_ROT3_DELTA := 15

## For SampleROI
param $ROI_ROT_MODE := "XOYS"
param $ROI_ROT1_START := 0
param $ROI_ROT1_END := 359
param $ROI_ROT1_DELTA := 30
$roi_rot1_loop := ($ROI_ROT1_END - $ROI_ROT1_START) / $ROI_ROT1_DELTA
param $ROI_ROT2_START := 0
param $ROI_ROT2_END := 359
param $ROI_ROT2_DELTA := 30
$roi_rot2_loop := ($ROI_ROT2_END - $ROI_ROT2_START) / $ROI_ROT2_DELTA
param $ROI_ROT3_START := 0
param $ROI_ROT3_END := 0
param $ROI_ROT3_DELTA := 30
$roi_rot3_loop := ($ROI_ROT3_END - $ROI_ROT3_START) / $ROI_ROT3_DELTA
param $ROI_SN := 1

# advanced param
## Mode 0: do not, 1: each, 2: all
advanced param $Mode_ROI := 1
advanced param $Mode_Ref := 1
advanced param $Mode_Cor := 1
## Flag true: do, false: do not
advanced param $Flag_3D := true
advanced param $Flag_3DWhole := true
advanced param $Flag_3D4S := true
advanced param $Flag_Projection := true
</pre>
今回はMode_ROIとMode_Corのみ1: each, 2: allの切り替えが可能としています。$roi_rot1_loopなどの[[変数束縛]]を追加していますが、これはeachのループ数のためでユーザが入力する必要はありません。 
 

これらのファイルは[[Media:PIONE-Advanced4-2.zip|こちら]]からダウンロードできます。 
 

===== 同じようなルールをまとめる =====
====== Preprocess ======
Mainで呼んでいるPreprocessのルールは下記のようにしていました。 
<table border="1">
<tr>
<th>Main.pione内のルール</th>
<th>サブルール</th>
<th>Makefile</th>
<th>説明</th>
</tr>
<tr>
<td>Preprocess</td>
<td>pad_padlst 
roi_smooth 
smooth_shrink 
shrink_pad 
</td>
<td>.lst.padlst 
.roi.smooth 
.smooth.shrink 
.shrink.pad 
</td>
<td>.padファイル一覧を作成 
.roiの平滑化して.smoothを作成 
.smoothを縮小して.shrinkを作成 
.shrinkを参照画像と同じサイズにパディングして.padを作成 
</td>
</tr>
</table>
 

これらの処理は全て入力ファイルと出力ファイルが１：１対応であり、.roi -> .smooth -> .shrinkの順番に作成して最終的に.padファイルのみを得ることを目的としています。このような場合はルールを分けずに１つのルールの中で処理を行った方がルール間のファイルのやり取りが最小限で済みます。（参照：[[#基本５の補足]]） 
 

<table border="1">
<tr>
<th></th>
<th>コード</th>
<th>処理結果（[[ProM]]）</th>
</tr>
<tr>
<td>(1) 分けた場合</td>
<td>
<pre>
Rule Preprocess
input '*.roi'
output '{$I[1][1]}.pad'
Flow
rule roi_smooth;
rule smooth_shrink;
rule shrink_pad;
End

#.roi.smooth:
Rule roi_smooth
input '*.roi'
output '{$I[1][1]}.smooth'
Action
mrcImageSmoothing -i {$I[1]} -o {$O[1]} -m 1 -r 4
End

#.smooth.shrink:
Rule smooth_shrink
input '*.smooth'
output '{$I[1][1]}.shrink'
Action
mrcImageShrink -i {$I[1]} -o {$O[1]} -S {$SHRINK}
End

#.shrink.pad:
Rule shrink_pad
input '*.shrink'
output '{$I[1][1]}.pad'
Action
width=`expr {$X_SIZE} / {$SHRINK}`
height=`expr {$Y_SIZE} / {$SHRINK}`
mrcImagePad -i {$I[1]} -o {$O[1]} -W ${width} -H ${height}
End
</pre>
</td>
<td>[[画像:Outdata-PIONE-Advanced4-5.png]]</td>
</tr>
<tr>
<td>(2) まとめた場合</td>
<td>
<pre>
Rule Preprocess
input '*.roi'
output '{$I[1][1]}.pad'
Action
# roi_smooth
mrcImageSmoothing -i {$I[1]} -o {$I[1][1]}.smooth -m 1 -r 4

# smooth_shrink
mrcImageShrink -i {$I[1][1]}.smooth -o {$I[1][1]}.shrink -S {$SHRINK}

# shrink_pad
width=`expr {$X_SIZE} / {$SHRINK}`
height=`expr {$Y_SIZE} / {$SHRINK}`
mrcImagePad -i {$I[1][1]}.shrink -o {$O[1]} -W ${width} -H ${height}
End
</pre>
</td>
<td>[[画像:Outdata-PIONE-Advanced4-6.png|540px]]</td>
</tr>
</table>
 

上記の(2)のようにルールをまとめることで(1)に比べて、１ファイル毎に１秒ほど時間が短縮できました。 
 

====== Create_fit, Create_3dlst, Create_3d ======
　Create_fitは各.padファイルから.fitファイルや.corinfoファイルをそれぞれ１：１で作成しています。また、Create_3dlstでもfit_3dinfoまでは１：１対応の処理です。 

<table border="1">
<tr>
<th>Main.pione内のルール</th>
<th>サブルール</th>
<th>Makefile</th>
<th>説明</th>
</tr>
<tr>
<td>Create_fit</td>
<td>-</td>
<td>.pad.fit</td>
<td>.padから.stackを使って相関マップ.corinfoを作成（最も近い画像.fitも作成）</td>
</tr>
<tr>
<td>Create_3dlst</td>
<td>fit_3dinfo 
Sum_3dinfo_3dlst</td>
<td>.fit.3dinfo</td>
<td>各相関マップ.corinfoから相関値が最大の角度を集めてリスト.3dlstを作成</td>
</tr>
<tr>
<td>Create_3d</td>
<td>Reconstruct_3dlst_3d 
Convert_3d_ds6</td>
<td>.3dlst.3d 
.3d.ds6</td>
<td>リスト.3dlstと.fitを使って３次元像.3d及び.ds6を作成（1/8サイズ）</td>
</tr>
</table>
 

従って、この部分もまとめた方が良いでしょう。同様にfit_3dwholeinfoとfit_3d4sinfoもまとめます。この処理は前項目のPreprocessともまとめられそうですが、[[単粒子解析]]のための３次元再構成では角度決定処理を繰り返し行うので、この部分は分けて実装します。（参照：[[単粒子解析#繰り返し（精密化）]]）また、Create_3dlstのSum_3dinfo_3dlstとCreate_3dなども一つにまとめられます。 
 

まとめたCreate_fit_each 
<pre>
Rule Create_fit_each
input '*.pad'
input '*.stack'
if ($Flag_3DWhole or $Flag_3D4S)
input '{$I[1][1]}.roi'
end
if $Flag_3D
output '{$I[1][1]}.fit'
output '{$I[1][1]}.3dinfo'
end
if $Flag_3DWhole
output '{$I[1][1]}.shift'
output '{$I[1][1]}.3dwholeinfo'
end
if $Flag_3D4S
output '{$I[1][1]}.4shift'
output '{$I[1][1]}.3d4sinfo'
end
Action
# Create_fit
mrcImageAutoRotationCorrelation -i {$I[1]} -r {$I[2]} -fit {$I[1][1]}.fit -O {$I[1][1]}.corinfo \
-n {$N_ROT} -m 18 -nRot1 {$N_ROT1} -nRot2 {$N_ROT2} -nRot3 {$N_ROT3} > /dev/null

# fit_3dinfo
if {$Flag_3D} ; then
awk '/Cor/ { print $18,$16,$2,$3,$4,"0.0"}' {$I[1][1]}.corinfo | sort -r | sed -e s/pad/fit/ > {$I[1][1]}.3dinfolst
head -n 1 {$I[1][1]}.3dinfolst | awk ' {print $2,$3,$4,$5,$6,$1'} > {$I[1][1]}.3dinfo
fi

# fit_3dwholeinfo
if {$Flag_3DWhole} ; then
awk '/Cor/ { print $18,$16,$2,$3,$4,$9,$11,$12}' {$I[1][1]}.corinfo | sort -r | sed -e s/pad/shift/ > {$I[1][1]}.3dwholeinfolst
head -n 1 {$I[1][1]}.3dwholeinfolst | awk ' {print $2,$3,$4,$5,$6,$7,$8,$1'} > {$I[1][1]}.3dwholeinfo
X=`awk '{print -{$SHRINK}*$6; }' {$I[1][1]}.3dwholeinfo`;
Y=`awk '{print -{$SHRINK}*$7; }' {$I[1][1]}.3dwholeinfo`;
echo $X,$Y; mrcImageShift -i {$I[1][1]}.roi -o {$I[1][1]}.shift -x $X -y $Y -z 0
fi

# fit_3d4sinfo
if {$Flag_3D4S} ; then
awk '/Cor/ { print $18,$16,$2,$3,$4,$9,$11,$12}' {$I[1][1]}.corinfo | sort -r | sed -e s/pad/4shift/ > {$I[1][1]}.3d4sinfolst
head -n 1 {$I[1][1]}.3d4sinfolst | awk ' {print $2,$3,$4,$5,$6,$7,$8,$1'} > {$I[1][1]}.3d4sinfo
X=`awk '{print -{$SHRINK4S}*$6; }' {$I[1][1]}.3d4sinfo`;
Y=`awk '{print -{$SHRINK4S}*$7; }' {$I[1][1]}.3d4sinfo`;
echo $X,$Y;
mrcImageShrink -i {$I[1][1]}.roi -o {$I[1][1]}.4shrink -S {$SHRINK4S}
width=`expr {$X_SIZE} / {$SHRINK4S}`
height=`expr {$Y_SIZE} / {$SHRINK4S}`
mrcImagePad -i {$I[1][1]}.4shrink -o {$I[1][1]}.4spad -W ${width} -H ${height}
mrcImageShift -i {$I[1][1]}.4spad -o {$I[1][1]}.4shift -x $X -y $Y -z 0
fi
End
</pre>
 

まとめたCreate_3d
<pre>
Rule Create_3d
input '*.3dinfo'.all
input '*.fit'.all
output '{$filename}.3d'
output '{$filename}.ds6'
param $filename
Action
# Sum_3dinfo_3dlst
for info in {$I[1]}
do
cat $info >> {$filename}.3dlst
done

# Reconstruct_3dlst_3d
mrc2Dto3D -I {$filename}.3dlst -o {$O[1]} -InterpolationMode 2 -Double -DoubleCounter {$filename}.3dcounter -CounterThreshold 0.5 -m 1 -WeightMode 6

# Convert_3d_ds6
mrc2map -i {$O[1]} -o {$O[2]} -m 3
End
</pre>
Create_3d4s, Create_3dwholeについても同様にまとめています。 
 

===== 動作比較 =====
作成した[[PIONE定義書]]と前回分や元の[[Makefile]]との処理時間を比較して、ここまでの実装の効果があったかを検証します。今回は.3dファイルの作成に関して比較します。 
 

では、[[:Media:PIONE-Advanced4-3.zip|今回の実装]]による処理時間を複数のタスク（-t 2と-t 4）で実行してみます。 
 

-t 2の結果（５分強） 
[[画像:Outdata-PIONE-Advanced4-14.png]] 
 

-t4の結果（３分強） 
[[画像:Outdata-PIONE-Advanced4-15.png]] 
 

１つのマシンにおいて２つのタスクに分けることで４分削減して約5/9（改善前からは２分削減して約5/7）になりました。さらに４つのタスクに分けることで６分削減して約1/3になりました。入力ファイル（256×256：36枚）の場合において、今回の実装で有効な並列処理ができたと言えるでしょう。 
 

==== 機能追加のための実装 ====
今回は作成した[[PIONE定義書]]や[[パッケージ]]についてさらに機能を追加する方法を考えます。 
 

===== 粒子の切り出しを追加する =====
.roiファイルが無い場合にユーザが切り出した画像を使用できるように追加してみましょう。（参照：[[単粒子解析#電子顕微鏡画像から粒子画像の抽出]]） 
 

この機能は.roiファイルを作成するものなので、Create_ROIと同列と考えて、$Mode_ROIに3を追加してこのときにユーザが切り出すようにします。 
 

Main.pione（Cutout_ROIを追加） 
<pre>
case $Mode_ROI
when 1
rule Create_Sample3d
rule Create_SampleROI_each {rot1: (0.upto($roi_rot1_loop))*$ROI_ROT1_DELTA, rot2: (0.upto($roi_rot2_loop))*$ROI_ROT2_DELTA, rot3: (0.upto($roi_rot3_loop))*$ROI_ROT3_DELTA}
when 2
rule Create_Sample3d
rule Create_SampleROI_all
when 3
rule Cutout_ROI
end
</pre>
 

Parameter.pione（コメントを追加） 
<pre>
## Mode 0: do not, 1: each, 2: all, 3: use Display2
advanced param $Mode_ROI := 3
</pre>
 

Create_SampleROI.pione（Cutout_ROIを追加） 
<pre>
Rule Cutout_ROI
input '*.mrc'
output '*.roi'.all
output '*.tiff'.all
Action
Display2 -i {$I[1]}
for data in $(ls *.roi)
do
mrc2tiff -i ${data} -o ${data}.tiff
done
End
</pre>
切り出しには[[Display2]]を使用しています。 
 

新しいルールを作成して、呼び出すだけで簡単に機能を追加することができました。 
 

===== 繰り返し機能を追加する =====
[[単粒子解析]]のための３次元再構成は出来上がった３次元像を参照像として繰り返して、３次元像の精密化を行うこともあります。今回はこの部分の対応を作成してみましょう。 
 

Parameter.pione（繰り返し回数を追加） 
<pre>
## For repeat count
param $Repeat_Count := 2
</pre>
 

Repeat_3d 
<pre>
Rule Repeat_3d
input '*-{$count}.3d'
output '{$I[1][1]}-{$count + 1}.stack'
param $count
Action
mrc3Dto2D -i {$I[1]} -o {$O[1]} -m 1 -InterpolationMode 2 -EulerMode {$REF_ROT_MODE} \
-Rot1 {$REF_ROT1_START} {$REF_ROT1_END} {$REF_ROT1_DELTA} \
-Rot2 {$REF_ROT2_START} {$REF_ROT2_END} {$REF_ROT2_DELTA} \
-Rot3 {$REF_ROT3_START} {$REF_ROT3_END} {$REF_ROT3_DELTA}
End
</pre>
上記のように作成された.3dファイルから.stackファイルを作成します。このとき繰り返し回数が分かるようにファイル名にを付加しています。また、下記のルールについても繰り返し回数の対応を行います。 
 

Create_stack.pione 
<pre>
output '{$I[1][1]}-1.stack'
</pre>
 

Main.pione（出力ファイルの宣言） 
<pre>
if $Flag_3D
output '{$I[1][1]}-{$Repeat_Count}.3d'
output '{$I[1][1]}-{$Repeat_Count}.ds6'
end
</pre>
繰り返しの最後のファイルのみを出力するようにします。 
 

Main.pione（Flow） 
<pre>
case $Mode_3D
when 1
rule Create_fit_each

if $Flag_3D
rule Create_3d {filename: $I[1][1].str(), count: 1.upto($Repeat_Count)}
rule Repeat_3d {count: 1.upto($Repeat_Count - 1)}
end
</pre>
Create_3d, Repeat_3dを繰り返し回数分呼び出します。 
 

Create_stack.pione（最初の.stackファイル名に1を付加）
<pre>
output '{$I[1][1]}-1.stack'
</pre>
 

Create_fit_each.pione（.3dのための処理） 
<pre>
Rule Create_fit_each
input '*.pad'
input '*-*.stack'
if $Flag_3D
output '{$I[1][1]}.fit-{$I[2][2]}'
output '{$I[1][1]}.3dinfo-{$I[2][2]}'
end
Action
# Create_fit
mrcImageAutoRotationCorrelation -i {$I[1]} -r {$I[2]} -fit {$I[1][1]}.fit-{$I[2][2]} -O {$I[1][1]}.corinfo-{$I[2][2]} \
-n {$N_ROT} -m 18 -nRot1 {$N_ROT1} -nRot2 {$N_ROT2} -nRot3 {$N_ROT3} > /dev/null

# fit_3dinfo
if {$Flag_3D} ; then
awk '/Cor/ { print $18,$16,$2,$3,$4,"0.0"}' {$I[1][1]}.corinfo-{$I[2][2]} | sort -r | sed -e s/pad/fit-{$I[2][2]}/ > {$I[1][1]}.3dinfolst-{$I[2][2]}
head -n 1 {$I[1][1]}.3dinfolst-{$I[2][2]} | awk ' {print $2,$3,$4,$5,$6,$1'} > {$I[1][1]}.3dinfo-{$I[2][2]}
fi

</pre>
 

Create_3d.pione 
<pre>
Rule Create_3d
input '*.3dinfo-{$count}'.all
input '*.fit-{$count}'.all
output '{$filename}-{$count}.3d'
output '{$filename}-{$count}.ds6'
param $filename
param $count
Action
# Sum_3dinfo_3dlst
for info in {$I[1]}
do
cat $info >> {$filename}-{$count}.3dlst
done

# Reconstruct_3dlst_3d
mrc2Dto3D -I {$filename}-{$count}.3dlst -o {$O[1]} -InterpolationMode 2 -Double -DoubleCounter {$filename}-{$count}.3dcounter -CounterThreshold 0.5 -m 1 -WeightMode 6

# Convert_3d_ds6
mrc2map -i {$O[1]} -o {$O[2]} -m 3
End
</pre>

このように実装することで指定した数Repeat_Countに応じた繰り返し処理を行うように機能追加ができます。 
 

=== 応用５（クラスター解析） ===
次は[[クラスター解析]]のMakefileを元にして速度改善を考えてみましょう。[http://sourceforge.jp/projects/eos/scm/git/base/archive/master/Integration/2DClustering/?format=zip こちらのMakefile]を元にしています。今回はMakefileのコマンドも使用します。これにより全体の実装量を削減できますが、makeコマンド実行するときに入出力ファイルがそれぞれ何に当たるのかを注意する必要があります。 
 

==== 前処理 ====
前処理の並列化を考えます。これまでの[[PIONE定義書]]ではeachを使って1ファイル毎の並列処理として実装を行いました。今回はいくつかのグループに分けて、そのグループ毎で並列化を行うようにしてみます。 
 

<pre>
param $task := 2

Rule Main
input '*.roi'.all
input 'Makefile'
input 'Makefile.config'
output '*.pad'.all
Flow
rule Preprocess {filelist:$I[1].all, num:1.upto($task), length:$I[1].length()}
End

Rule Preprocess
input $filelist.nth(((($num-1)*((($length-1)/$task)+1))+1).upto((($num*((($length-1)/$task)+1))|$length).min()))
input 'Makefile'
input 'Makefile.config'
output '*.pad'.all
Action
for data in {$I[1]}
do
make $(basename ${data} ".roi").pad
done
End
</pre>
Preprocess内の処理はMakefile内のコマンドに委ねるようにしています。入力ファイルがかなり複雑となっていますが、これは次のように考えています。 
 

まずパラメータtaskで分割したいグループ数を決め、この数だけルールPreprocessの呼び出すように考えます。 
*filelistにはファイル自体でなく、ファイル名の一覧を送る
*numには分割数の内の何番目かを送る
*lengthにはファイル名の要素数を送る
次にPreprocess側では受け取ったパラメータからグループ毎で使用するファイル名を決め、それらを入力ファイルとすることで分割を実現します。なお、今回使用しているupto, length, minなどのメソッドについては[[PIONEの式]]を参照して下さい。 
 

次のグラフは上記の前処理を256, 512, 1024, 2048, 4096(pixel)の画像ファイル100枚を入力としてタスク数1, 2, 4, 10で動作したときの処理時間です。 
[[画像:Outdata-PIONE-Advanced5-1.png]] 
allは（前処理に関する）全体の処理、processは前処理自体、otherはそれ以外のファイル通信などの処理時間を表しています。 
 

ここでタスク数を増やしたときの変化に注目します。全体の処理時間についてt=1（シングルタスク）との比率は下記のようになりました。 
[[画像:Outdata-PIONE-Advanced5-2.png]] 
2048サイズまでは処理時間が短くなっています。今回はタスク数を増やしても速度の改善は見られません。タスク数を増やすことによって前処理自体の時間は軽減されますが、それ以外のファイル通信など処理で逆に時間がかかってしまうためです。 
 

<table>
<tr>
<td>[[画像:Outdata-PIONE-Advanced5-5.png]]</td>
<td>[[画像:Outdata-PIONE-Advanced5-6.png]]</td>
</tr>
<tr>
<td>前処理はタスク数が多い方が速くなる（このマシンではt=4まで）</td>
<td>タスク数が多くなると並列処理の準備（ファイル通信など）は時間がかかる。</td>
</tr>
<table>
 

==== クラスター解析による分類 ====
本処理のクラスター解析による分類の速度改善を考えてみましょう。Makefileでは[[mrcImageClusterAnalysis]]によって画像毎の相関リストを作って近い画像同士を分類して、グループを作り、それぞれのグループによって平均画像を作成しています。今回はこのグループ毎の平均画像に対してリファインメントを行う部分にて並列化を行ってみます。 
 

===== グループ分け =====
まず、全ての.padファイルを入力としてmakeコマンドによってクラスター解析による分類を行います。すると、分類された.padファイルの一覧all.padsortlstと樹形図all.treeinfoが出力されるので、この2つのファイルを指定した分割数divideだけ分割してそれぞれ.lst .treeファイルを作成します。また、最初のmakeコマンドによって1回目の平均画像が得られますので、この画像がどのグループに属するのか番号付けして出力しています。（ルートに近く分割できない画像は0として番号付けする）下記はその実装例です。 
 

<pre>
Rule Process
input '*.pad'.all
input 'Makefile'
input 'Makefile.config'
output 'all.padsortlst'
output 'all.treeinfo'
output ((1.upto($divide).str())+".lst").d().all()
output ((1.upto($divide).str())+".tree").d().all()
output ("*.pad"+(1.upto($divide).str())).d().all()
output ("*.avg"+(0.upto($divide).str())).d().all()
output '*.avglst'.all
Action
ls -1 *.pad > all.padlst
make Log
make LogPS

cp {$O[1]} 1.lst
cp {$O[2]} 1.tree
for (( i=2; i<={$divide}; i++ ))
do
max=0
for data in $(ls *.lst)
do
num=$(wc -l ${data} | awk '{printf $1}')
if [ ${num} -gt ${max} ] ; then
max=${num}
maxlist="${data}"
fi
done
maxtree="$(basename ${maxlist} '.lst').tree"
root=$(head -1 ${maxtree} | awk '{printf("%d", $1)}')
rootname=$(basename $(awk -v val=${root} '$2==val {printf("%s", $1)}' ${maxlist}) ".pad")
cp ${maxlist} ${rootname}.avglst
cp ${rootname}.pad.avg ${rootname}.pad.avg0
maxpos=$(awk -v val=${root} '$2==val {printf("%f", $3)}' ${maxlist})
line=$(awk -v val=${root} '$2==val {print NR}' ${maxlist})
head -$((${line} - 1)) ${maxlist} > ${i}.lst
tail -$(($(wc -l ${maxlist} | awk '{print $1}') - ${line} + 1)) ${maxlist} > tmp
cp tmp ${maxlist}

max_t=$(wc -l ${maxtree} | awk '{printf $1}')
max_l=$(wc -l ${maxlist} | awk '{printf $1}')
line_t=$(awk -v val=${root} '$1==val {print NR}' ${maxtree})
head -$((${max_l} + ${line_t} - 1)) ${maxtree} | tail -$((${max_l} - 1)) > tmp
tail -$((${max_t} - ${max_l})) ${maxtree} > ${i}.tree
cp tmp ${maxtree}
done

for (( i=1; i<={$divide}; i++ ))
do
for data in $(awk '{print $1}' ${i}.lst)
do
cp ${data} ${data}${i}
cp ${data}.avg ${data}.avg${i}
done
done
End
</pre>
.lst .treeファイルが最大のものから２分割するようにし、分割する前の.lstファイルを.avglstとしてグループ0の平均画像のデータとして取り扱うようにしています。 
 

===== グループ毎の平均画像のリファインメント =====
グループ分けされた平均画像についてのリファインメントを行います。まず、.lst .treeファイルから平均画像を構成している画像リスト.avglstファイルを作成します。そして、そのリストを使用してリファインメントを行います。このとき、[[mrcImageAutoRotationCorrelation]]と[[mrcImageAverage]]を使用していますが、設定内容をMakefileと同じにするためにMakefile.configから特定のパラメータを読み取るようにしています。 
 

<pre>
Rule Refinement
input '*.pad{$num}'.all
input '*.avg{$num}'.all
input '{$num}.lst'
input '{$num}.tree'
input 'Makefile.config'
output ($I[1][1].str()+".pad.avg").d().all()
output ($I[1][1].str()+".pad.avg.tiff").d().all()
output ($I[1][1].str()+".pad.avg"+$num.str()+".tiff").d().all()
Action
max=$(wc -l {$num}.tree | awk '{printf $1}')
data=$(head -1 {$num}.tree)
i=$(echo ${data} | awk '{print $1}')
name=$(basename $(awk -v i=${i} '$2==i {print $1}' {$num}.lst) ".pad")
cp {$num}.lst ${name}.avglst
cp {$num}.tree ${name}.tree

for (( k=1; k<=max ; k++ ))
do
i=$(head -${k} {$num}.tree | tail -1 | awk '{print $1}')
name=$(basename $(awk -v i=${i} '$2==i {print $1}' {$num}.lst) ".pad")

if [ $(wc -l ${name}.avglst | awk '{print $1}') -gt 2 ] ; then
tpos=$(awk -v i=${i} '$2==i {print NR}' ${name}.avglst)
tline=$(wc -l ${name}.avglst | awk '{print $1}')

head -$((${tline} - ${tpos} + 1)) ${name}.tree | tail -$((${tline} - ${tpos})) > tmp
i_sub1=$(head -1 tmp | tail -1 | awk '{print $1}')
name_sub1=$(basename $(awk -v i=${i_sub1} '$2==i {print $1}' ${name}.avglst) ".pad")
if [ $(wc -l tmp | awk '{print $1}') -ne 0 ] ; then
cp tmp ${name_sub1}.tree
tail -$((${tline} - ${tpos} + 1)) ${name}.avglst > ${name_sub1}.avglst
fi

tail -$((${tpos} - 2)) ${name}.tree > tmp
i_sub2=$(head -1 tmp | awk '{print $1}')
name_sub2=$(basename $(awk -v i=${i_sub2} '$2==i {print $1}' ${name}.avglst) ".pad")
if [ $(wc -l tmp | awk '{print $1}') -ne 0 ] ; then
cp tmp ${name_sub2}.tree
head -$((${tpos} - 1)) ${name}.avglst > ${name_sub2}.avglst
fi
fi
done

cat Makefile.config | sed -e s/'='/' '/ > Makefile.config.tmp
ClusterCorrelationMode=$(awk '$1=="ClusterCorrelationMode" {print $2}' Makefile.config.tmp)
ClusterRotationRangeMin=$(awk '$1=="ClusterRotationRangeMin" {print $2}' Makefile.config.tmp)
ClusterRotationRangeMax=$(awk '$1=="ClusterRotationRangeMax" {print $2}' Makefile.config.tmp)
ClusterRotationRangePartitionNumber=$(awk '$1=="ClusterRotationRangePartitionNumber" {print $2}' Makefile.config.tmp)
ClusterRotationIterationNumber=$(awk '$1=="ClusterRotationIterationNumber" {print $2}' Makefile.config.tmp)

for data in $(ls *.avglst)
do
name=$(basename ${data} ".avglst")
awk '{print $1}' ${data} | sed -e s/.pad/.pad.fit/ > ${name}.fitlst
cp ${name}.pad.avg{$num} ${name}.pad.avg
for (( i=0; i < {$refine}; i++ ))
do
for element in $(awk '{print $1}' ${data})
do
mrcImageAutoRotationCorrelation -i ${element}{$num} -r ${name}.pad.avg -fit ${element}.fit -cor ${element}.cor \
-Method ${ClusterRotationCorrelationMode} -m ${ClusterCorrelationMode} -Iter ${ClusterRotationIterationNumber} \
-range ${ClusterRotationRangeMin} ${ClusterRotationRangeMax} -n ${ClusterRotationRangePartitionNumber}
done

mrcImageAverage -i ${name}.fitlst -o ${name}.pad.avg
done
mrc2tiff -i ${name}.pad.avg -o ${name}.pad.avg.tiff
mrc2tiff -i ${name}.pad.avg{$num} -o ${name}.pad.avg{$num}.tiff
done
End
</pre>
 

===== ルートに近い平均画像のリファインメント =====
ルートに近く、分割できない平均画像についてもリファインメントを行います。ルールRefinementとほとんど同じですが、平均画像を構成している画像リストはすでにルールProcessで作成されているので、本処理のみで十分です。 
 

<pre>
Rule RefinementRoot
input '*.pad'.all
input '*.pad.avg0'.all
input ($I[2][1].str()+".avglst").d().all()
input 'Makefile.config'
output ($I[1][1].str()+".pad.avg").d().all()
output ($I[1][1].str()+".pad.avg.tiff").d().all()
output ($I[1][1].str()+".pad.avg0.tiff").d().all()
Action
cat Makefile.config | sed -e s/'='/' '/ > Makefile.config.tmp
ClusterCorrelationMode=$(awk '$1=="ClusterCorrelationMode" {print $2}' Makefile.config.tmp)
ClusterRotationRangeMin=$(awk '$1=="ClusterRotationRangeMin" {print $2}' Makefile.config.tmp)
ClusterRotationRangeMax=$(awk '$1=="ClusterRotationRangeMax" {print $2}' Makefile.config.tmp)
ClusterRotationRangePartitionNumber=$(awk '$1=="ClusterRotationRangePartitionNumber" {print $2}' Makefile.config.tmp)
ClusterRotationIterationNumber=$(awk '$1=="ClusterRotationIterationNumber" {print $2}' Makefile.config.tmp)
ClusterRotationCorrelationMode=$(awk '$1=="ClusterRotationCorrelationMode" {print $2}' Makefile.config.tmp)

for data in $(ls *.avglst)
do
name=$(basename ${data} ".avglst")
awk '{print $1}' ${data} | sed -e s/.pad/.pad.fit/ > ${name}.fitlst
cp ${name}.pad.avg0 ${name}.pad.avg
for (( i=0; i < {$refine}; i++ ))
do
for element in $(awk '{print $1}' ${data})
do
mrcImageAutoRotationCorrelation -i ${element} -r ${name}.pad.avg -fit ${element}.fit -cor ${element}.cor \
-Method ${ClusterRotationCorrelationMode} -m ${ClusterCorrelationMode} -Iter ${ClusterRotationIterationNumber} \
-range ${ClusterRotationRangeMin} ${ClusterRotationRangeMax} -n ${ClusterRotationRangePartitionNumber}
done

mrcImageAverage -i ${name}.fitlst -o ${name}.pad.avg
done
mrc2tiff -i ${name}.pad.avg -o ${name}.pad.avg.tiff
mrc2tiff -i ${name}.pad.avg0 -o ${name}.pad.avg0.tiff
done
End
</pre>
 

===== 動作検証 =====
では実行してみましょう。 
今回は入力画像を32×32(Pixel)を54枚用意しリファインメントを5回として、-t毎の実行時間を検証してみます。画像は全処理のログで、今回の実装部分はRefinement（ログの２分辺り）からです。（入力画像は同ディレクトリ内のMain_ROIr.pioneで作成しました） 
 

t=1（5分強） 
[[画像:Outdata-PIONE-Advanced5-t1.png]] 
 

t=2（4分程度） 
[[画像:Outdata-PIONE-Advanced5-t2.png|730px]] 
 

t=4（3分強） 
[[画像:Outdata-PIONE-Advanced5-t4.png|670px]] 
 

タスク数を増やす毎に処理時間の短縮（本処理が半分以下に軽減）が実現できています。今回の検証では入力画像の枚数が少ないので、ファイル通信があまりなく本処理の時間にほぼ直接影響されるため並列処理の効果が得られました。 
 

==== Makefile内のパラメータ設定 ====
今回は処理の一部をMakefileの処理に委ねていますが、使用するパラメータはMakefile.configに設定するようになっています。パラメータ管理をまとめて行えるようにこの部分のパラメータもPIONEで設定できるようにしてみましょう。 
 

元のMakefile.configは下記のようになっています。 
<pre>
# Makefile.config for 2D Clustering

# Cluster Name
CLUSTER=all

# Pad Parameter
# Width(Nx) before shrinking
PADWIDTH=32
# Height(Ny) before shrinking
PADHEIGHT=32
# Shrink for Speed Up in clustering
SHRINK=1
# Pad Mode
PADMODE=13
# LOWPASS
LowPassMode=4
LowPassResolution=0.1

# Clustering
ClusterCorrelationMode=19
#
ClusterRotationRangeMin=0
ClusterRotationRangeMax=360
ClusterRotationRangePartitionNumber=72
ClusterRotationIterationNumber=2
ClusterRotationCorrelationMode=0
#
ClusterMode=2

# ClusterShow
TreeRootPositionX=0
TreeRootPositionY=400
TreeScaleX=10
TreeScaleY=100
TreeOffset=1e1
</pre>
今回はPIONEで設定したパラメータから上記のようなMakefile.configを作成することで各種パラメータの管理を全てPIONE定義書内で行えるようにします。 
 

Main.pione内に下記の内容を追加します。 
<pre>
# Cluster Name
param $CLUSTER := "all"

# Pad Parameter
# Width(Nx) before shrinking
param $PADWIDTH := 32
# Height(Ny) before shrinking
param $PADHEIGHT := 32
# Shrink for Speed Up in clustering
param $SHRINK := 1
# Pad Mode
param $PADMODE := 13
# LOWPASS
param $LowPassMode := 4
param $LowPassResolution := 0.1

# Clustering
param $ClusterCorrelationMode := 19
#
param $ClusterRotationRangeMin := 0
param $ClusterRotationRangeMax := 360
param $ClusterRotationRangePartitionNumber := 72
param $ClusterRotationIterationNumber := 2
param $ClusterRotationCorrelationMode := 0
#
param $ClusterMode := 2

# ClusterShow
param $TreeRootPositionX := 0
param $TreeRootPositionY := 400
param $TreeScaleX := 10
param $TreeScaleY := 100
param $TreeOffset := "1e1"

# Sequence with Keys(Makefile.config for 2D Clustering)
$Config := ("CLUSTER":$CLUSTER) |
("PADWIDTH":$PADWIDTH) |
("PADHEIGHT":$PADHEIGHT) |
("SHRINK":$SHRINK) |
("PADMODE":$PADMODE) |
("LowPassMode":$LowPassMode) |
("LowPassResolution":$LowPassResolution) |
("ClusterCorrelationMode":$ClusterCorrelationMode) |
("ClusterRotationRangeMin":$ClusterRotationRangeMin) |
("ClusterRotationRangeMax":$ClusterRotationRangeMax) |
("ClusterRotationRangePartitionNumber":$ClusterRotationRangePartitionNumber) |
("ClusterRotationIterationNumber":$ClusterRotationIterationNumber) |
("ClusterRotationCorrelationMode":$ClusterRotationCorrelationMode) |
("ClusterMode":$ClusterMode) |
("TreeRootPositionX":$TreeRootPositionX) |
("TreeRootPositionY":$TreeRootPositionY) |
("TreeScaleX":$TreeScaleX) |
("TreeScaleY":$TreeScaleY) |
("TreeOffset":$TreeOffset)
</pre>
パラメータを設定しています。$TreeOffset := "1e1"のようにeを使用するような数値はPIONEの記法にはありませんので、" "で囲んで一旦文字列として設定しておきます。また、Makefile.configに書き出す処理を簡潔にするために設定したパラメータをキー付きシーケンスとして$Configに登録しています。新たにパラメータを追加したときは$Configにも追加するようにすれば後述で作成されるMakefile.configにも追加されるようになります。Configに値を直接登録することもできますが、実行ユーザが[[pione-client#オプション --params]]を利用してパラメータ設定できるようにparamで定義してから登録しています。 
 

では、Makefile.config作成用のルールを作成して、Mainに追加します。 
<pre>
Rule SetParam
output 'Makefile.config'
Action
key=({$Config.keys})
value=({$Config.values})
for (( i=0; i<{$Config.length}; i++ ))
do
echo "${key[${i}]}=${value[${i}]}" >> {$O[1]}
done
End
</pre>
それぞれのパラメータをキー付きシーケンスとしてConfigに登録しているので、[[PIONEの式#キー付きシーケンス]]のメソッドkeysとvaluesを利用してパラメータ名と値を得ることができますので、Makefile.configに書き込むことができます。 
 

SetParamで作成したMakefile.config
<pre>
CLUSTER=all
PADWIDTH=32
PADHEIGHT=32
SHRINK=1
PADMODE=13
LowPassMode=4
LowPassResolution=0.1
ClusterCorrelationMode=19
ClusterRotationRangeMin=0
ClusterRotationRangeMax=360
ClusterRotationRangePartitionNumber=72
ClusterRotationIterationNumber=2
ClusterRotationCorrelationMode=0
ClusterMode=2
TreeRootPositionX=0
TreeRootPositionY=400
TreeScaleX=10
TreeScaleY=100
TreeOffset=1e1
</pre>
元のMakefile.configと同様のファイルを作成することができました。 
 

==== 分類の点数付け ====
[[単粒子解析#クラスター解析]]で行った分類されたグループと元のモデルとの一致数を算出する処理を追加してみましょう。 
<pre>
# For GroupingPoint
param $filename := "121p-shift2"
param $ROT2 := (0.upto(3)) * 45

Rule GroupingPoint
input '*.lst'.all
input '*.tree'.all
output '{$CLUSTER}.groupinfo'
Action
array_rot2=( {$ROT2} )

total=0
element_total=0
for num in {$I[1][1]}
do
element_num=$(wc -l ${num}.lst | awk '{print $1}')
element_total=$(( ${element_total} + ${element_num} ))
data=$(head -1 ${num}.tree)
root_i=$(echo ${data} | awk '{print $1}')
root_name=$(basename $(awk -v i=${root_i} '$2==i {print $1}' ${num}.lst) ".pad")

max=0
max_i=0
i=0
include_max_rot2=${array_rot2[0]}
for rot2 in ${array_rot2[@]}
do
include_num=$(grep "{$filename}-0-${rot2}-" ${num}.lst | wc -l | awk '{print $1}')
if [ ${include_num} -gt ${max} ] ; then
max=${include_num}
include_max_rot2=${rot2}
max_i=${i}
fi
i=$(( ${i} + 1 ))
done

echo "group${root_i}: match: ${max} owner: ${include_max_rot2}" >> {$O[1]}
total=$(( ${total} + ${max} ))

unset array_rot2[${max_i}]
array_rot2=("${array_rot2[@]}")
done
echo " total: ${total}" >> {$O[1]}
echo "${total} ${element_total}" | awk '{printf("parcentage: %f\n", $1 / $2)}' >> {$O[1]}
End
</pre>
今回、入力する使用ファイルはモデル有りで作成したサンプル画像のみを対象としています。（実際の[[電子顕微鏡]][[画像]]での分類の評価はもっと複雑で、手法としては[[クラスター解析]]や[[単粒子解析#クラスター解析]]で議論する内容）ファイル名がAAAA-0-Y-Z-S.roiのような画像（同ディレクトリMain_ROI.pioneで作成される）でYの回転の違いのみでグループ分けされることを前提として、モデルとの一致数を.groupファイルに出力します。上記のパラメータでは各グループをY回転0°, 45°, 90°, 135°の内、最も一致するグループに当てはめて、その一致数と割合を下記のように出力します。 
 

<pre>
group000022: match: 9 owner: 45
group000013: match: 8 owner: 135
group000028: match: 0 owner: 0
group000001: match: 8 owner: 90
total: 25
parcentage: 0.625000
</pre>
group0000NNのNNはグループ分けされたルートのNo.、owenerは最も一致した角度、matchは一致数をそれぞれ表します。またtotalは一致数の合計、percentageは割合です。 
 

今回はYの回転のみで分類を評価していますが、パラメータやfor文、ログの記述部分などを追加することで、Xの回転も組み合わせて分類することは可能です。また、パラメータROT2は(0.upto(3)) * 45のように等間隔で角度を与えていますが、|で繋いで直接記述することでMain_ROIr.pioneで作成した画像のように等間隔でないファイルについても同様に評価することができます。 
 
<pre>
param $ROT2 := (17.888783 | 114.250336 | 173.771591 | 273.340057)
</pre>