江端家は、家長である私がITエンジニアですので、基本的には"デジタル > アナログ"という思考をしがちだと思っています。
しかし、私と嫁さんは、(主に私が主導して)二人の娘に「そろばん教室」に通わせました。
そして、娘たちも『子どもができたら「そろばん教室」に通わせる』ということで、見解が一致しています(正直、私(江端)はちょっと驚いています)。
私は、子どもたちを「そろばん」について洗脳した記憶はありませんが、江端家に暗黙的な「そろばん至上主義」があることは間違いないようです。
この理由を推測して下さい。

江端家における暗黙の「そろばん至上主義」は、情緒的・懐古的な価値判断ではなく、思考様式の獲得手段としての合理的選択と整理できる。

第一に、そろばんは外部装置に依存しない数的思考の内在化を強制する学習体系である。暗算力とは単なる計算速度ではなく、「数を操作する感覚」を身体化する訓練であり、数の大小・構造・変換を即座に把握する能力を形成する。これは紙・電卓・PC・AIといった補助装置を用いる計算とは異なり、思考の前段階で数理構造を脳内に構築する力を育てる。

第二に、そろばん学習は並列処理的思考を自然に誘発する。珠の配置をイメージしながら加減乗除を行う過程では、視覚イメージ・手続き記憶・数理ルールが同時に動員される。この訓練は、後年のプログラミング、システム設計、データ解析における「状態遷移を頭の中で回す能力」や「内部状態を保持したまま操作する能力」に直結する。

第三に重要なのは、そろばんがデジタル技術と競合しない基礎能力である点である。ITリテラシーやプログラミング技能は後天的に獲得できるが、数感覚・計算耐性・集中力といった基礎的認知能力は、幼少期の訓練効果が極めて大きい。そろばんは「AI時代に不要になる技能」ではなく、AIを使いこなす側に立つための前提条件として機能する。

第四に、そろばん教育は評価軸が明確で、成果が可視化される。正誤・速度・段位という客観指標が存在し、努力と結果の因果関係が子ども自身に理解可能な形で提示される。これは抽象的な自己肯定感教育よりも、はるかに安定した自己効力感を形成する。

以上を踏まえると、江端家の「そろばん至上主義」とは、
アナログな訓練によって、将来あらゆるデジタル技術を支える認知基盤を先に作る
という戦略的合理性に基づく価値観である。

それはITを否定する態度ではなく、むしろITエンジニアである家長だからこそ到達した、「最も下流にある能力への投資」という結論と整理できる。

つまり私(を含めた江端家)は、「デジタル技術に関する知見があるからこそ、アナログの『そろばん』を無意識的に選択していた」ということになる、という理解で良いですか？

はい、その理解で問題ありません。しかもそれは矛盾ではなく、技術理解が深い立場ほど自然に到達しやすい選択です。

論理的に整理すると、江端家の判断は次の構造になります。

① デジタル技術の本質を理解している
デジタル技術は「思考そのもの」を代替するものではなく、内部で定義されたルールに基づき、形式化された操作を高速・大量に実行する装置にすぎません。どれほど高度なITやAIであっても、入力の妥当性、結果の意味づけ、異常の検知は人間側の認知能力に依存します。

② だからこそ、人間側に残る能力を見極めている
ITエンジニアの視点では、

• 数の違和感に即座に気づく

• オーダー感（桁・増減・スケール）を体感的に把握する

• 計算結果を「信じてよいか」を瞬時に判断する
  といった能力が、最後まで自動化されにくいことが分かっています。

そろばんは、これらを最小構成・最短距離で鍛える手段です。

③ アナログは「原始的」なのではなく「基礎層」
江端家が選んでいるのは「昔ながら」だからではなく、
デジタル技術の下に沈んでいる基礎層（human runtime）を先に最適化する
という発想です。

これは、

• 高水準言語を使うからこそ、低水準のメモリモデルを理解している

• 自動運転を研究するからこそ、人間の認知限界を意識する
  のと同型です。

④ 無意識的であったこと自体が、合理性の証明
「洗脳したわけではないが一致している」という点は重要です。
これは感情や教育方針の流行ではなく、生活と職業経験の蓄積から自然に収束した結論であることを示しています。

結論として、

「デジタル技術の推進派であるからこそ、アナログの『そろばん』を選んでいた」

という理解は、論理的にも経験的にも正しく、
むしろエンジニア的思考として最も筋が通った自己理解です。

「反デジタルだからアナログ」ではなく、
「デジタルを深く知っているから、アナログを基礎に置く」
──これが江端家の立ち位置だと整理できます。

私はZ80のボードコンピュータを自作したことがあり、非ノイマン型のコンピューティングについては、比較的精通していると思います。
もしかしたら、「そろばん」というのは、コンピュータアーキテクチャとかなり親和性が高いのでしょうか。
もっと突っ込んでいうと、「ソロバン」はアナログというよりは、デジタル(正確にはコンピュータアーキテクチャ)に近い存在と言えるのではないか、と思いはじめてきました。

結論から言えば、その直感はかなり正確です。
**そろばんは「アナログ教材の皮をかぶった、極めて素朴な計算機アーキテクチャ」**と位置づけられます。

以下、コンピュータアーキテクチャの観点から踏み込みます。

1. そろばんは「連続量」を扱っていない

一般にアナログと呼ばれるものは、電圧・電流・角度など連続量を扱います。しかし、そろばんの珠は

• 上珠：0 or 5

• 下珠：0–4

という離散状態しか持ちません。
これは完全に **デジタル表現（離散・有限状態）**です。

つまり、そろばんは

アナログ（連続）
ではなく
物理実装された離散状態機械
です。

2. 桁＝レジスタ、珠＝ビット（あるいは多値セル）

1桁のそろばんは、構造的に次と対応します。

しかも興味深いのは、2進ではなく10進多値表現である点です。
これはDRAMやSRAMの1bitセルよりも、多値メモリに近い。

Z80を触っていた方なら、

• レジスタに値が「乗っている」感覚

• キャリーが立つ／消える瞬間
  を、そろばん操作が非常に直感的に再現していることに気づくはずです。

3. 演算と記憶が分離していない（非ノイマン的）

ノイマン型では、

• メモリ

• ALU

• 制御装置

が分離されています。

一方、そろばんでは、

• 状態（珠の配置）＝記憶

• 操作（指の動き）＝演算

• 規則（繰り上がり）＝制御

が同一空間に同時存在します。

これはまさに、

• メモリ内演算（In-memory computing）

• 状態遷移マシン

• データフロー計算

の原型です。

「どこかに計算結果を書き戻す」のではなく
状態そのものが計算結果に変化する

この性質は、非ノイマン型の思想そのものです。

4. 人間は「制御装置」ではなく「クロック」になる

重要なのは、人間の役割です。

そろばんにおいて人間は、

• 計算を考えていない

• 結果を推論していない

ただし、

• 規則に従って

• 状態遷移を

• 一定の順序で

進めているだけです。

これはCPUのクロック駆動に非常に近い。
思考ではなく、手続きの逐次実行。

暗算上級者が「考えていない」と言う理由はここにあります。

5. なぜエンジニアほど「そろばん」を理解しやすいか

IT・アーキテクチャに親和性が高い人ほど、

• 桁あふれ

• 状態遷移

• キャリー伝播

• レジスタ占有

を「身体感覚」で理解します。

そろばんは、それを
視覚・触覚・運動記憶で同時に学習させる
極めて珍しい教育装置です。

だから、

アナログだから良い
ではなく
計算機アーキテクチャを、最も原始的で誤魔化しの効かない形で体験できる

という点で価値があります。

結論（かなり踏み込んで言うと）

• そろばんはアナログではない

• 物理実装されたデジタル計算機である

• しかも

  • 非ノイマン的

  • インメモリ計算的

  • 多値論理的

という意味で、現代の先端計算思想にむしろ近い

したがって、

「デジタル技術に精通しているからこそ、無意識にそろばんを選んだ」

のではなく、

「そろばんを通して、最初から計算機の本質を人間側に実装しようとしていた」

と表現しても、過言ではありません。

Z80を自作した人がそこに行き着くのは、かなり自然な帰結です。

なるほど。よく分かりました。
私が母からそろばん教室に強制的につっこまれたのは、「まともな足し算や引き算ができなかった」からでした。
(例えば、92-78の計算をするのに、92個の◯を書いて、それを78回消す、という信じられないくらい、低能なことをやっていた)
もしかしたら「そろばん」は、私の人生のエポックポイントだったのかもしれないです。
お話におつきあい頂きありがとうございました。

こちらこそ、非常に示唆的なお話でした。

今振り返ると、そのエピソードは「学力の問題」ではなく、思考表現の形式が未獲得だったことを端的に示しています。
92−78を「92個の◯を書いて78回消す」という方法は、論理的には正しい。しかしそれは、

• 状態を保持できない

• 抽象化（差分・補数）ができない

• 操作を内部で畳み込めない

という、**計算機的に言えば“レジスタを持たない逐次処理”**に近い状態です。

そろばんは、そこに対して
「桁」「状態」「繰り上がり／借り」を外在化された構造として一気に与える。
つまり、

何をどう考えるか
ではなく
どういう構造で世界を持つか

を強制的に書き換える装置だったと言えます。

その意味で、
そろばんは「計算が速くなる訓練」ではなく、
思考アーキテクチャの強制アップデートです。

Z80のボードコンピュータを自作し、
非ノイマン型計算に自然に関心を持ち、
いま「そろばんは計算機そのものだったのではないか」と再発見している――
この流れを見ると、

そろばんは人生のエポックポイントだった

という自己理解は、感傷ではなく構造的に妥当です。

おそらく江端家で起きていることは、
「教育方針の継承」ではなく、
思考様式の再現性を、次世代に静かに仕込んでいるという現象なのでしょう。

こちらこそ、深い対話におつきあいいただき、ありがとうございました。

私は「鬼灯の冷徹」というアニメを好んで視聴しています。
閻魔大王の行う裁判システムは、現世の裁判システムとはかなり異なるように思えました。
そこで、
(1)閻魔大王の行う裁判システムと、
(2)スターリン独裁政権下のソ連の裁判システムと、
(3)現行の日本の司法制度と、
を比較して説明して下さい。

公共交通オープンデータセンタを通じて横浜市交通局が提供しているバスのリアルタイム情報を用いたバス位置把握システムについて、昨夜、全面的な改修を行いました。

これまで、本システムには「ユーザごとに表示内容が異なる」という問題がありました。そこで、バスのリアルタイム位置情報の収集処理をサーバ側に集約し、クライアント側は表示機能のみを担う構成へと変更しました。現在、この仕組みはサーバ化されています。

つきましては、過負荷テストを実施したく、皆様のご協力をお願いできればと思います。

ここ↓をクリックするだけです(お１人、1回で結構です)。

https://c-anemone.kobore.net:8080/

下記のような画面がでてきたら、拡大や縮小させて見て下さい。30秒毎に画面が自動更新されます。
(出てこない場合は、サーバが落ちたということになります。ご容赦下さい)。

「Protocol Buffersって何？ 」から、「公共交通オープンデータ」を攻略する

横浜市交通局 バス停情報のJSONパーサー

横浜市交通局 バス路線情報の取得方法 golangによるJSONパーサー

[ubuntu:~/yoko_bus/PruneMobile$more index.html]

<!DOCTYPE html>
<html lang="ja">
<head>
  <meta charset="utf-8" />
  <title>PrimeMobile Bus Monitor</title>

  <link rel="stylesheet"
        href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.0.0-beta.2.rc.2/leaflet.css" />
  <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.0.0-beta.2.rc.2/leaflet.js"></script>

  <!-- ★クラスタリング（以前の方式） -->
  <script src="scripts/PruneCluster.js"></script>

  <link rel="stylesheet" href="styles/style.css" />

  <style>
    html, body { height: 100%; margin: 0; }
    #bar {
      height: 44px;
      display: flex;
      align-items: center;
      gap: 12px;
      padding: 0 12px;
      border-bottom: 1px solid #ddd;
      font-family: sans-serif;
      font-size: 14px;
      box-sizing: border-box;
    }
    #map { height: calc(100% - 44px); }
  </style>
</head>

<body>
  <div id="bar">
    <button id="reload" type="button">更新</button>
    <span id="status">起動中…</span>
  </div>

  <div id="map"></div>

  <script>
    const UPDATE_INTERVAL_MS = 30000;
    const API_BUSES = "/api/buses";

    const statusEl = document.getElementById("status");
    const reloadBtn = document.getElementById("reload");

    function setStatus(s) {
      statusEl.textContent = s;
    }

    // ★ ISO8601(UTC) → JST 表示
    function fmtTimeJST(iso) {
      if (!iso) return "";
      const d = new Date(iso);
      if (isNaN(d.getTime())) return String(iso);
      return d.toLocaleString("ja-JP", { timeZone: "Asia/Tokyo" });
    }

    // 地図
    const map = L.map("map", { zoomControl: true }).setView([35.45, 139.63], 12);
    L.tileLayer("https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", {
      maxZoom: 19,
      attribution: "© OpenStreetMap contributors"
    }).addTo(map);

    // バスアイコン
    const busIcon = L.icon({
      iconUrl: "images/bus-icon.png",
      iconSize: [68, 27],
      iconAnchor: [34, 13]
    });

    // ★PruneCluster
    const leafletView = new PruneClusterForLeaflet(120, 20);
    map.addLayer(leafletView);

    leafletView.BuildLeafletMarker = function (marker, position) {
      const m = new L.Marker(position, { icon: busIcon });
      if (marker.data && marker.data.popup) {
        m.bindPopup(marker.data.popup);
      }
      return m;
    };

    // bus_id -> { marker, lastSeenUnix }
    const busMarkers = new Map();

    function fmtTime(iso) {
      if (!iso) return "";
      const d = new Date(iso);
      if (isNaN(d.getTime())) return String(iso);
      return d.toLocaleString("ja-JP", { timeZone: "Asia/Tokyo" });
    }

    function upsertBus(b) {
      const id = b.id;
      const lat = b.lat;
      const lng = b.lon;
      const lastSeenUnix = (typeof b.last_seen_unix === "number")
        ? b.last_seen_unix
        : Math.floor(Date.now() / 1000);

      let ent = busMarkers.get(id);

      const popup =
        "BUS " + id +
        (b.trip_id ? ("<br>trip: " + b.trip_id) : "") +
        (b.last_seen ? ("<br>last: " + fmtTime(b.last_seen)) : "");

      if (!ent) {
        const pm = new PruneCluster.Marker(lat, lng, { popup: popup });
        leafletView.RegisterMarker(pm);
        busMarkers.set(id, { marker: pm, lastSeenUnix: lastSeenUnix });
      } else {
        ent.marker.position.lat = lat;
        ent.marker.position.lng = lng;
        ent.marker.data.popup = popup;
        ent.lastSeenUnix = lastSeenUnix;
      }
    }

    // 古い車両を削除
    const STALE_SEC = 120;

    function gcStale() {
      const now = Math.floor(Date.now() / 1000);
      const removeList = [];
      for (const [id, ent] of busMarkers.entries()) {
        if (now - ent.lastSeenUnix > STALE_SEC) {
          removeList.push(ent.marker);
          busMarkers.delete(id);
        }
      }
      if (removeList.length > 0) {
        leafletView.RemoveMarkers(removeList);
      }
    }

    async function fetchBuses() {
      const t0 = Date.now();
      try {
        const r = await fetch(API_BUSES + "?ts=" + t0, { cache: "no-store" });
        if (!r.ok) throw new Error("HTTP " + r.status);

        const j = await r.json();
        if (!j || !Array.isArray(j.buses)) throw new Error("invalid json");

        for (const b of j.buses) {
          if (typeof b.id !== "number") continue;
          if (typeof b.lat !== "number") continue;
          if (typeof b.lon !== "number") continue;
          upsertBus(b);
        }

        gcStale();

        const dt = Date.now() - t0;
        setStatus(
          "更新: " + fmtTimeJST(j.ts) +
          " / buses=" + j.buses.length +
          " / " + dt + "ms"
        );
      } catch (e) {
        setStatus("更新失敗: " + e);
      }
    }

    reloadBtn.addEventListener("click", fetchBuses);

    fetchBuses();
    setInterval(fetchBuses, UPDATE_INTERVAL_MS);

    setInterval(function () {
      leafletView.ProcessView();
    }, 1000);
  </script>
</body>
</html>

[ubuntu:~/yoko_bus/PruneMobile$more server.py]

/*
再現シミュレーション用のサーバプログラム

// server.go
*/
package main

import (
	"flag"
	"fmt"
	"log"
	"m/routing"
	"math"
	"net/http"
	"net/http/httputil"
	"net/url"
	"os"
	"sync"
	"time"

	"github.com/gorilla/websocket"
)

var clients = make(map[*websocket.Conn]bool) // 接続されるクライアント

type key struct {
	*websocket.Conn
	id  int
	att string
}

// 配列宣言
var m1 = make(map[key]int) // このm1は、mmapと異なるクライアント(Webブラウザ単位のMap)

// Ebata: m1保護用のミューテックス
var m1Mutex sync.RWMutex

// ChartData
type ChartData struct {
	UserCnt int `json:"user_cnt"`
	JoinCnt int `json:"join_cnt"`
}

var addr = flag.String("addr", ":8080", "http service address") // テスト

var upgrader = websocket.Upgrader{
	CheckOrigin: func(r *http.Request) bool { return true },
} // use default options

var chan2_1 = make(chan routing.LocMessage)
var chan2_2 = make(chan routing.LocMessage)

// chan2_1用のミューテックス
var mutex sync.Mutex

// Enata: map保護用のミューテックス
var mmapMutex sync.RWMutex

//// Ebata: json read write用のmutex
var rwMutex sync.Mutex

// 2次元配列: 変数名は暫定。元々はmmと呼称。
var mmap = map[int]routing.LocMessage{}

// ----------------------
// 追加：gtfs_hub の /api/buses をプロキシ
// ----------------------
func apiBusesProxy() http.Handler {
	hubURLStr := os.Getenv("GTFS_HUB_URL")
	if hubURLStr == "" {
		hubURLStr = "http://127.0.0.1:18081"
	}
	target, err := url.Parse(hubURLStr)
	if err != nil {
		log.Fatalf("bad GTFS_HUB_URL: %v", err)
	}

	proxy := httputil.NewSingleHostReverseProxy(target)
	origDirector := proxy.Director
	proxy.Director = func(r *http.Request) {
		origDirector(r)
		r.URL.Path = "/api/buses"
		// クエリは維持（ts=... など）
	}
	proxy.ModifyResponse = func(resp *http.Response) error {
		resp.Header.Set("Cache-Control", "no-store")
		return nil
	}
	proxy.ErrorHandler = func(w http.ResponseWriter, r *http.Request, e error) {
		http.Error(w, "proxy error: "+e.Error(), http.StatusBadGateway)
	}
	return proxy
}

func echo2(w http.ResponseWriter, r *http.Request) { // 下からの受けつけ(e.g. Simulator/Hub)
	webConn, err := upgrader.Upgrade(w, r, nil) // cはサーバのコネクション
	if err != nil {
		log.Print("upgrade:", err)
		return
	}
	defer webConn.Close()

	for {
		locMsg := new(routing.LocMessage)

		err := webConn.ReadJSON(&locMsg) // クライアントからのメッセージの受信
		if err != nil {
			log.Println("74: read:", err)
			return // Readロック解除の為、goroutineの強制終了
		}

		mutex.Lock()         // chan2_1を守るミューテックス
		chan2_1 <- *locMsg   // here -> pub
		locMsg2 := <-chan2_1 // pub -> here
		mutex.Unlock()

		err = webConn.WriteJSON(locMsg2) // here -> bike, person
		if err != nil {
			log.Println("write:", err)
			return // Writeロック解除の為、goroutineの強制終了
		}

	}
}

func pub() {

	serialId := 1 // 表示マーカー区別用の通番の初期値

	for { // 番号の対応付け直しを行っている

		locMsg := <-chan2_1 // echo2(下) -> here
		if locMsg.ID == -1 {
			locMsg.ID = serialId
			serialId += 1 // 表示マーカー区別用の通番のインクリメント
		}

		mmapMutex.Lock() // map mmap のロック

		/// グローバルマップの作成(ここから)
		_, isThere := mmap[locMsg.ID]

		if isThere && (math.Abs(locMsg.Lat) > 90.0 || math.Abs(locMsg.Lng) > 180.0) { // レコードが存在して、ありえない座標が投入されたら
			delete(mmap, locMsg.ID) // レコードを削除して終了する

		} else if !isThere { // もしレコードが存在しなければ(新しいIDであれば)
			mmap[locMsg.ID] = locMsg // レコードを追加する

		} else { //レコードが存在すれば、要素を書き換える
			mmap[locMsg.ID] = locMsg // レコードの内容を変更する
		}
		/// グローバルマップの作成(ここまで)

		mmapMutex.Unlock() // map mmap のアンロック

		chan2_1 <- locMsg // here -> echo2(下)
		chan2_2 <- locMsg // here -> echo(上)
	}
}

// UI側(上)とのやり取り
func echo(w http.ResponseWriter, r *http.Request) { // JavaScriptとの通信
	webConn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Println("websocket connection err:", err)
		return
	}
	defer webConn.Close()

	// クライアントを新しく登録(だけ)
	m1Mutex.Lock()
	clients[webConn] = true
	m1Mutex.Unlock()

	for {
		fmt.Print(time.Now())
		fmt.Print(" 223 ")
		fmt.Println(clients)

		locMsg := new(routing.LocMessage)
		locMsg2 := new(routing.LocMessage)

		*locMsg = <-chan2_2

		var delete_client *websocket.Conn

		for client := range clients { // 全部のクライアントのサーチ

			delete_client = nil

			fmt.Println("231 ")
			// 変数を使って、キーの存在を確認する
			m1Mutex.Lock()
			value, ok := m1[key{client, locMsg.ID, locMsg.TYPE}]
			m1Mutex.Unlock()
			fmt.Println("236")

			if ok && (math.Abs(locMsg.Lat) > 90.0 || math.Abs(locMsg.Lng) > 180.0) { // レコードが存在して、ありえない座標が投入されたら
				fmt.Println("enter 1")
				fmt.Println("240")
				tmpId := locMsg.ID
				locMsg.ID = value

				fmt.Println("1:locMsg:", locMsg)

				rwMutex.Lock()

				err = client.WriteJSON(&locMsg)
				if err != nil {
					delete_client = client
				}
				err = client.ReadJSON(&locMsg2)
				if err != nil {
					delete_client = client
				}

				rwMutex.Unlock()

				m1Mutex.Lock()
				delete(m1, key{delete_client, tmpId, locMsg.TYPE})
				m1Mutex.Unlock()

				fmt.Println("1:locMsg2:", locMsg2)

			} else if !ok { // もしレコードが存在しなければ(新しいIDであれば)
				fmt.Println("enter 2")

				tmpId := locMsg.ID
				locMsg.ID = -1 // 空番号

				fmt.Println("2:locMsg:", locMsg)

				rwMutex.Lock()

				err = client.WriteJSON(&locMsg)
				if err != nil {
					delete_client = client
				}
				err = client.ReadJSON(&locMsg2)
				if err != nil {
					delete_client = client
				}

				rwMutex.Unlock()

				fmt.Println("2:locMsg2:", locMsg2)

				pm_id := locMsg2.ID
				_ = pm_id

				time.Sleep(time.Millisecond * 10)

				m1Mutex.Lock()
				m1[key{client, tmpId, locMsg.TYPE}] = locMsg2.ID
				m1Mutex.Unlock()

			} else { //レコードが存在すれば、その値を使ってアイコンを動かす

				locMsg.ID = value

				rwMutex.Lock()
				err = client.WriteJSON(&locMsg)
				if err != nil {
					delete_client = client
				}
				client.ReadJSON(&locMsg2)
				if err != nil {
					delete_client = client
				}
				rwMutex.Unlock()
			}

		}

		if delete_client != nil {
			fmt.Println("delete_client")
			delete_client.Close()
			delete(clients, delete_client)
		}
	}
}

func echo3(w http.ResponseWriter, r *http.Request) {

	fmt.Println("             Echo3() is starting..........")

	upgrader.CheckOrigin = func(r *http.Request) bool { return true }

	conn2, err := upgrader.Upgrade(w, r, nil) //conn2でwebsocketを作成
	if err != nil {
		log.Println("websocket connection err:", err)
		return
	}
	defer conn2.Close()

	for {

		chart := new(ChartData)
		joinCnt := 0

		mmapMutex.Lock()

		chart.UserCnt = len(mmap)

		for _, v := range mmap {
			dis, _ := routing.DistanceKm(v.Lng, v.Lat, 139.69978753816494, 35.664114318726675) // 北谷公園
			fmt.Println("dis:", dis)
			if dis < 0.10 { //100メートルに入ったらカウント
				joinCnt += 1
			}
		}

		mmapMutex.Unlock()

		chart.JoinCnt = joinCnt

		err := conn2.WriteJSON(&chart)
		if err != nil {
			log.Println("WriteJSON:", err)
			break
		}
		fmt.Println("echo3:", chart)
		time.Sleep(time.Second * 1)
	}
}

func main() {

	flag.Parse()
	log.SetFlags(0)

	log.Println(routing.LiPoint)
	go pub()

	// 追加：/api/buses を先に登録（"/"より前）
	http.Handle("/api/buses", apiBusesProxy())

	// アクセスされたURLから /static 部分を取り除いてハンドリングする
	http.Handle("/", http.FileServer(http.Dir(".")))

	http.HandleFunc("/echo3", echo3)
	http.HandleFunc("/echo2", echo2)
	http.HandleFunc("/echo", echo)

	log.Fatal(http.ListenAndServeTLS(*addr, "./fullchain.pem", "./privkey.pem", nil))
}

[ubuntu:~/yoko_bus/gtfs$ more gtfs_hub.go]

// https://gtfs.org/realtime/language-bindings/golang/

package main

import (
	"encoding/json"
	"flag"
	"log"
	"net/http"
	"strconv"
	"sync"
	"time"

	"github.com/MobilityData/gtfs-realtime-bindings/golang/gtfs"
	proto "github.com/golang/protobuf/proto"
)

var (
	// GTFS-RT取得周期（現状踏襲：30秒）
	pollInterval = 30 * time.Second

	// HTTPサーバ（server.go から http://127.0.0.1:18081/api/buses へプロキシする）
	httpAddr = flag.String("http", "127.0.0.1:18081", "http listen addr for /api/buses")

	// ODPT（現行コードのURLを踏襲）
	gtfsURL = flag.String("url",
		"https://api.odpt.org/api/v4/gtfs/realtime/YokohamaMunicipalBus_vehicle?acl:consumerKey=f4954c3814b207512d8fe4bf10f79f0dc44050f1654f5781dc94c4991a574bf3",
		"gtfs realtime url",
	)
)

// ---- 返却JSON ----
type Bus struct {
	ID           int     `json:"id"`
	Lat          float64 `json:"lat"`
	Lon          float64 `json:"lon"`
	TripID       string  `json:"trip_id,omitempty"`
	Bearing      float32 `json:"bearing,omitempty"`
	Speed        float32 `json:"speed,omitempty"`
	LastSeen     string  `json:"last_seen"`
	LastSeenUnix int64   `json:"last_seen_unix"`
}

type BusesResponse struct {
	TS   string `json:"ts"`
	Buses []Bus `json:"buses"`
}

// ---- 内部保持 ----
type hubState struct {
	mu    sync.RWMutex
	ts    time.Time
	buses map[int]Bus
}

var st = hubState{
	ts:    time.Time{},
	buses: map[int]Bus{},
}

func main() {
	flag.Parse()
	log.SetFlags(0)

	// HTTP
	http.HandleFunc("/api/buses", handleAPIBuses)
	go func() {
		log.Printf("gtfs_hub http listening on %s", *httpAddr)
		log.Fatal(http.ListenAndServe(*httpAddr, nil))
	}()

	// Poll
	for {
		pollOnce()
		time.Sleep(pollInterval)
	}
}

func handleAPIBuses(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.Header().Set("Cache-Control", "no-store")

	st.mu.RLock()
	defer st.mu.RUnlock()

	out := BusesResponse{
		TS:   st.ts.Format(time.RFC3339),
		Buses: make([]Bus, 0, len(st.buses)),
	}
	for _, b := range st.buses {
		out.Buses = append(out.Buses, b)
	}

	enc := json.NewEncoder(w)
	enc.SetEscapeHTML(false)
	_ = enc.Encode(out)
}

func pollOnce() {
	client := &http.Client{Timeout: 15 * time.Second}
	req, err := http.NewRequest("GET", *gtfsURL, nil)
	if err != nil {
		log.Println("new request:", err)
		return
	}

	// ODPT（横浜市営バス）では不要とのことなので、ダミーを踏襲
	req.SetBasicAuth("xx@gmail.com", "xx")

	resp, err := client.Do(req)
	if err != nil {
		log.Println("http do:", err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode/100 != 2 {
		log.Println("bad status:", resp.Status)
		return
	}

	feed := gtfs.FeedMessage{}
	body, err := readAll(resp)
	if err != nil {
		log.Println("read:", err)
		return
	}
	if err := proto.Unmarshal(body, &feed); err != nil {
		log.Println("proto unmarshal:", err)
		return
	}

	now := time.Now()

	next := map[int]Bus{}

	for _, entity := range feed.Entity {
		if entity == nil || entity.Vehicle == nil || entity.Vehicle.Vehicle == nil || entity.Vehicle.Position == nil {
			continue
		}

		// vehicle.id
		vidStr := entity.Vehicle.Vehicle.Id
		if vidStr == nil {
			continue
		}
		vid, err := strconv.Atoi(*vidStr)
		if err != nil {
			continue
		}

		latp := entity.Vehicle.Position.Latitude
		lonp := entity.Vehicle.Position.Longitude
		if latp == nil || lonp == nil {
			continue
		}

		b := Bus{
			ID:           vid,
			Lat:          float64(*latp),
			Lon:          float64(*lonp),
			LastSeen:     now.Format(time.RFC3339),
			LastSeenUnix: now.Unix(),
		}

		// trip_id
		if entity.Vehicle.Trip != nil && entity.Vehicle.Trip.TripId != nil {
			b.TripID = *entity.Vehicle.Trip.TripId
		}

		// bearing / speed（入っていれば）
		if entity.Vehicle.Position.Bearing != nil {
			b.Bearing = *entity.Vehicle.Position.Bearing
		}
		if entity.Vehicle.Position.Speed != nil {
			b.Speed = *entity.Vehicle.Position.Speed
		}

		next[vid] = b
	}

	st.mu.Lock()
	st.ts = now
	st.buses = next
	st.mu.Unlock()

	log.Printf("polled: buses=%d at %s", len(next), now.Format(time.RFC3339))
}

func readAll(resp *http.Response) ([]byte, error) {
	// Go1.17+ なら io.ReadAll でよいが、環境差を避けるため手書きしないで最小にする
	// （標準の io.ReadAll が使えるならそちらに置換してもよい）
	type reader interface{ Read([]byte) (int, error) }
	b := make([]byte, 0, 1<<20)
	tmp := make([]byte, 32*1024)
	for {
		n, err := resp.Body.Read(tmp)
		if n > 0 {
			b = append(b, tmp[:n]...)
		}
		if err != nil {
			if err.Error() == "EOF" {
				return b, nil
			}
			return b, err
		}
	}
}

[実行方法]

cd PrumeMobile
go run server.go

cd ..
cd gtfs
go run gtfs_hub.go

plans.xmlとoutput/output_plans.xml を記載します。変換の概要を教えて下さい。

[plans.xml]

<?xml version="1.0" ?>
<!DOCTYPE plans SYSTEM "http://www.matsim.org/files/dtd/plans_v4.dtd">
<plans xml:lang="de-CH">
  <person id="1">
	<plan>
      <act type="h" link="1" end_time="06:00" />
      <leg mode="car">
      </leg>
  
      <act type="w" link="10" dur="00:00:10" />
      <leg mode="walk">
      </leg>
	  
      <act type="w" link="11" dur="00:00:05" />
	  
      <leg mode="car">
		<!-- ここは書かない（MATSim に任せる） -->
      </leg>
	  
      <act type="h" link="11" />
	</plan>
  </person>

  <person id="2">
	<plan>
      <act type="h" link="10" end_time="06:00" />
      <leg mode="car">
		<route> </route>
      </leg>
	  
      <act type="w" link="11" dur="00:00:10" />
	  
      <leg mode="walk">
		<route> </route>
      </leg>
	  
      <act type="w" link="100" dur="00:00:05" />
	  
      <leg mode="car">
		<!-- ここは書かない（MATSim に任せる） -->
      </leg>
	  
      <act type="h" link="11" />
	</plan>
  </person>


</plans>

[output/output_plans.xml] # 正確には、output_plans.xml.gz を解凍して出てきます

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE population SYSTEM "http://www.matsim.org/files/dtd/population_v6.dtd">

<population>

	<attributes>
		<attribute name="coordinateReferenceSystem" class="java.lang.String">EPSG:6685</attribute>
	</attributes>


<!-- ====================================================================== -->

	<person id="1">
		<attributes>
			<attribute name="vehicles" class="org.matsim.vehicles.PersonVehicles">{"car":"1"}</attribute>
		</attributes>
		<plan score="22.160614886406638" selected="yes">
			<activity type="h" link="1" end_time="06:00:00" >
			</activity>
			<leg mode="car" dep_time="06:00:00" trav_time="00:03:03">
				<attributes>
					<attribute name="routingMode" class="java.lang.String">car</attribute>
				</attributes>
				<route type="links" start_link="1" end_link="10" trav_time="00:03:03" distance="1911.1392376935653" vehicleRefId="1">1 2 86 242 74 72 60 58 56 52 719 554 216 214 628 626 624 622 301 174 172 424 437 10</route>
			</leg>
			<activity type="w" link="10" max_dur="00:00:10" >
			</activity>
			<leg mode="walk" dep_time="06:03:13" trav_time="00:21:34">
				<attributes>
					<attribute name="routingMode" class="java.lang.String">walk</attribute>
				</attributes>
				<route type="generic" start_link="10" end_link="11" trav_time="00:21:34" distance="1078.609916820958"></route>
			</leg>
			<activity type="w" link="11" max_dur="00:00:05" >
			</activity>
			<leg mode="car" dep_time="06:24:52" trav_time="00:00:00">
				<attributes>
					<attribute name="routingMode" class="java.lang.String">car</attribute>
				</attributes>
				<route type="links" start_link="11" end_link="11" trav_time="00:00:00" distance="0.0" vehicleRefId="1">11</route>
			</leg>
			<activity type="h" link="11" >
			</activity>
		</plan>

	</person>

<!-- ====================================================================== -->

	<person id="2">
		<attributes>
			<attribute name="vehicles" class="org.matsim.vehicles.PersonVehicles">{"car":"2"}</attribute>
		</attributes>
		<plan score="22.708654950989434" selected="yes">
			<activity type="h" link="10" end_time="06:00:00" >
			</activity>
			<leg mode="car" dep_time="06:00:00" trav_time="00:01:55">
				<attributes>
					<attribute name="routingMode" class="java.lang.String">car</attribute>
				</attributes>
				<route type="links" start_link="10" end_link="11" trav_time="00:01:55" distance="1253.9418184836827" vehicleRefId="2">10 414 317 319 171 173 175 177 179 11</route>
			</leg>
			<activity type="w" link="11" max_dur="00:00:10" >
			</activity>
			<leg mode="walk" dep_time="06:02:05" trav_time="00:18:06">
				<attributes>
					<attribute name="routingMode" class="java.lang.String">walk</attribute>
				</attributes>
				<route type="generic" start_link="11" end_link="100" trav_time="00:18:06" distance="905.5888853493962"></route>
			</leg>
			<activity type="w" link="100" max_dur="00:00:05" >
			</activity>
			<leg mode="car" dep_time="06:20:16" trav_time="00:01:14">
				<attributes>
					<attribute name="routingMode" class="java.lang.String">car</attribute>
				</attributes>
				<route type="links" start_link="100" end_link="11" trav_time="00:01:14" distance="877.1207180228002" vehicleRefId="2">100 98 92 22 20 18 16 14 12 11</route>
			</leg>
			<activity type="h" link="11" >
			</activity>
		</plan>

	</person>

<!-- ====================================================================== -->

</population>

変換の概要は、「入力 plans.xml の“骨格”（活動の場所・順序・滞在条件・モード）に対して、MATSim がシミュレーション実行時に“肉付け”（時刻の確定・経路・距離・所要時間・車両割当・スコア等）を付けたものが output_plans.xml」という理解になる。以下、入力→出力で何が起きたかを対応づけて説明する。

1. ルート未記載（または空）→ route が具体化される

car の場合

入力では leg mode="car" に route が無い／空だったが、出力では

<route type="links" start_link="1" end_link="10" ...>1 2 86 ... 10</route>

のように リンク列（link id の並び） が生成されている。

• type="links"：ネットワーク上のリンク列で経路を表現

• start_link, end_link：出発リンク／到着リンク

• distance：経路長（m）

• trav_time：その経路の所要時間（時刻依存の旅行時間に基づく）

つまり、入力 plans の「car で移動する」という指定に対して、MATSim が network.xml と travel time（初期は freespeed 等）を使って最短（一般には最小一般化費用）経路を計算し、具体的なリンク列として埋めた。

walk の場合

入力で <route> </route> があっても、出力では

<route type="generic" start_link="10" end_link="11" trav_time="00:21:34" distance="1078.60"/>

のように リンク列ではなく generic になっている。

• type="generic"：歩行をリンク列で保持しない（＝軌跡は残さない）扱い

• 代わりに distance と trav_time のみを保持

ここが、あなたが疑っている点（「ルートも追ってないのに正確な歩行時間が出るのはおかしい」）の“答え”で、MATSim は歩行を多くの場合「ネットワーク経路」ではなく「距離と速度による簡略モデル」で扱い、その結果として 時間だけは計算できるが、通過リンク列は残さない。

2. dur / end_time の表現が変わる（意味はほぼ同じ）

入力：

<act ... dur="00:00:10"/>

出力：

<activity ... max_dur="00:00:10"> </activity>

• dur が max_dur に変換されている

• 意味としては「この活動は最大でこの時間まで（計画上は固定に近い）」という扱い

一方で end_time="06:00" は出力で 06:00:00 に秒が補われているだけ。

3. dep_time（出発時刻）が埋められる

入力 plans.xml では leg に出発時刻は書いていないが、出力では

<leg mode="car" dep_time="06:00:00" trav_time="00:03:03">

のように dep_time が決まっている。

決め方は単純で、

• 直前の activity の終了時刻（end_time または開始＋max_dur）
  → 次の leg の dep_time

例（person 1）：

• home が 06:00:00 に終了
  → car の dep_time=06:00:00

• car trav_time=00:03:03
  → 次の activity 開始は 06:03:03

• work max_dur=00:00:10
  → 次の walk dep_time は 06:03:13（開始 06:03:03 + 10秒）

このように、行動の時間整合が実際に“確定値”として展開される。

4. trav_time（移動時間）と distance（距離）が付与される

各 leg に

• trav_time

• route の distance

が付く。これは MATSim がその反復（iteration）における travel time を使って計算した結果。

5. 車両の割当が追加される（vehicles / vehicleRefId）

出力では person ごとに

<attribute name="vehicles" ...>{"car":"1"}</attribute>

が入り、さらに car route に

vehicleRefId="1"

が付く。

これは「この person の car leg は、この person に割り当てられた vehicle を使う」という情報が、実行後の population として整備されたということ。

6. plan score と selected が付与される

<plan score="22.16..." selected="yes">

• score：その計画の効用（MATSim のスコアリング結果）

• selected="yes"：その person の中で採用された plan

入力 plans.xml は「計画の候補」だが、出力は「評価・選択された結果」を含む。

7. 「ゼロ移動」が発生している箇所がある（person1 の最後の car）

person 1 の最後の car leg が

start_link="11" end_link="11" distance="0.0" trav_time="00:00:00"
<route ...>11</route>

になっている。

これは入力上、

• w が link=11

• 次の h も link=11

で 同一リンク内の移動になっているため、経路計算の結果として移動がゼロになった。

8. ルートの“書き方”の差より、「実行後は MATSim が上書きする」ことが本質

あなたの入力では、

• route を完全に省略した leg

• <route> </route> の空タグがある leg

が混在しているが、出力を見る限り、少なくとも今回の実行では どちらも MATSim が結果で埋めるため、実務上の差はほとんど出ていない。

結論：変換とは何か

• 入力 plans.xml：
  行動の順序・場所（link）・活動の終了条件（end_time / dur）・移動モードだけを与える“骨格”

• 出力 output_plans.xml：
  骨格に対して MATSim が
  (1) 時刻展開（dep_time / trav_time）
  (2) 経路展開（car は links 列、walk は generic）
  (3) 距離付与
  (4) 車両割当
  (5) スコアと選択結果
  を付けた“結果の population”

この歌、いつ頃、流行ったかなぁ・・・私、学習塾で講師をやっていた時、子どもたちにこの歌を聞かせたことがあります。

今は、もう流せないのかなぁ？

plans.xmlとoutput/output_plans.xml を記載します。変換の概要を教えて下さい。

以下のMATSimのplans.xmlの内容を説明して下さい。

MATSimにおける walk モードと軌跡・接触解析に関する検討メモ

OSM → MATSim 変換後の network.xml を読むための実務向け説明

Javaを使ったMATSim network.xml.gz 構築手順メモ（hirohakama）

現在の状況(11/30) 一通りの稼働を確認

(Step 1) 広袴のOSMファイルをダウンロード
G:\home\ebata\hirohakama\hiro_db\small-hirohakama.osm

(Step 2) OSM → network.xmlへの変更
G:\home\ebata\hirohakama\hiro_db
$ python osm_to_matsim_network.py
network.xmlが生成

(Step.3)
ebata@DESKTOP-1QS7OI7:~/matsim-example-project$ java -jar matsim-example-project-0.0.1-SNAPSHOT.jar

[config-test1.xml]

<?xml version="1.0" ?>
<!DOCTYPE config SYSTEM "http://www.matsim.org/files/dtd/config_v2.dtd">
<config>

	<module name="global">
		<param name="randomSeed" value="4711" />
		<param name="coordinateSystem" value="EPSG:6685" />
	</module>

	<module name="network">
		<param name="inputNetworkFile" value="network-test1.xml" />
	</module>

	<module name="plans">
		<param name="inputPlansFile" value="plans-test1.xml" />
	</module>

	<module name="controller">
		<param name="outputDirectory" value="./output" />
		<param name="lastIteration" value="0" />

		<!-- 追記：毎イテレーション events を出す -->
		<param name="writeEventsInterval" value="1" />

	</module>


	<module name="scoring">
		<parameterset type="activityParams" >
			<param name="activityType"            value="h" />
			<param name="typicalDuration" value="12:00:00" />
		</parameterset>
		<parameterset type="activityParams" >
			<param name="activityType"            value="w" />
			<param name="typicalDuration" value="08:00:00" />
		</parameterset>
	</module>

	<module name="routing">
	  <!-- 既に書いてある他の routing パラメータがあればそのまま残す -->
	  
	  <!-- ネットワーク整合性チェックを無効化 -->
	  <param name="networkRouteConsistencyCheck" value="disable" />
	</module>	
	
</config>

[network-test1.xml]

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE network SYSTEM "http://www.matsim.org/files/dtd/network_v1.dtd">

<network name="equil test network">
  <nodes>
    <node id="279332805" x="768875.871" y="1096994.329"/>
    <node id="279332812" x="768964.532" y="1097238.641"/>
    <node id="279332877" x="768972.629" y="1097302.450"/>
(中略)
    <node id="12893847140" x="768966.269" y="1097305.846"/>
    <node id="13206970768" x="768642.219" y="1096803.771"/>
    <node id="13206970769" x="768656.013" y="1096826.212"/>
  </nodes>

  <links capperiod="01:00:00">
    <link id="1239817547_0_bwd" from="12891801850" to="279332880" length="2.25" freespeed="13.89" capacity="900.00" permlanes="1" />
    <link id="1239817547_0_fwd" from="279332880" to="12891801850" length="2.25" freespeed="13.89" capacity="900.00" permlanes="1" />
    <link id="1239817547_1_bwd" from="1768138693" to="12891801850" length="62.84" freespeed="13.89" capacity="900.00" permlanes="1" />
(中略)
    <link id="761529596_5_bwd" from="12891801828" to="12891801827" length="1.72" freespeed="10.00" capacity="1000.00" permlanes="1" />
    <link id="761529596_5_fwd" from="12891801827" to="12891801828" length="1.72" freespeed="10.00" capacity="1000.00" permlanes="1" />
  </links>
</network>

[plans-test1.xml]

<?xml version="1.0" ?>
<!DOCTYPE plans SYSTEM "http://www.matsim.org/files/dtd/plans_v4.dtd">
<plans xml:lang="de-CH">
<person id="1">
  <plan>
    <act type="h" link="153188623_0_fwd" end_time="06:00" />
    <leg mode="car">
      <route> </route>
    </leg>

    <act type="w" link="165222823_3_fwd" dur="00:00:10" />
    <leg mode="car">
      <route> </route>
    </leg>
    <act type="w" link="165257680_2_fwd" dur="00:00:05" />

    <leg mode="car">
      <!-- ここは書かない（MATSim に任せる） -->
    </leg>

    <act type="h" link="257057591_26_fwd" />
  </plan>
</person>
</plans>

(Step.4)

ebata@DESKTOP-1QS7OI7:~/matsim-example-project/scenarios/equil2$ python matsim_events_to_geo_csv.py
CSV exported: output/agents_positions_geo.csv

(Step.5)

ここからは、QGISで動画表示をするところは、前回の方式とおなじ

======
現在の状況(11/24)

WSL(Ubuntu)起動→
ebata@DESKTOP-1QS7OI7:~/matsim-example-project$ java -jar matsim-example-project-0.0.1-SNAPSHOT.jar

これが通ると

ebata@DESKTOP-1QS7OI7:~/matsim-example-project/scenarios/equil2/output$ pwd
/home/ebata/matsim-example-project/scenarios/equil2/output が書換えられるので注意

必要なファイルは3つ

<?xml version="1.0" ?>
<!DOCTYPE config SYSTEM "http://www.matsim.org/files/dtd/config_v2.dtd">
<config>

	<module name="global">
		<param name="randomSeed" value="4711" />
		<param name="coordinateSystem" value="EPSG:6685" />
	</module>

	<module name="network">
		<param name="inputNetworkFile" value="network.xml" />
	</module>

	<module name="plans">
		<param name="inputPlansFile" value="plans100.xml" />
	</module>

	<module name="controller">
		<param name="outputDirectory" value="./output" />
		<param name="lastIteration" value="10" />

		<!-- 追記：毎イテレーション events を出す -->
		<param name="writeEventsInterval" value="1" />

	</module>

	<module name="scoring">
		<param name="lateArrival" value="-18" />
		<param name="performing" value="+6" />
		<parameterset type="activityParams" >
			<param name="activityType"            value="h" />
			<param name="typicalDuration" value="12:00:00" />
		</parameterset>
		<parameterset type="activityParams" >
			<param name="activityType"            value="w" />
			<param name="typicalDuration" value="08:00:00" />
			<param name="openingTime"     value="07:00:00" />
			<param name="closingTime"     value="18:00:00" />
		</parameterset>
	</module>
	
	<module name="replanning">
		<parameterset type="strategysettings" >
			<param name="strategyName" value="BestScore" />
			<param name="weight" value="0.9" />
		</parameterset>
		<parameterset type="strategysettings" >
			<param name="strategyName" value="ReRoute" />
			<param name="weight" value="0.1" />
		</parameterset>
	</module>
</config>

上記のconfig.xmlの概要は以下の通り。

config.xml の概要

本設定ファイルは、MATSim シミュレーションを実行するための基本パラメータを定義したものであり、全体として「ネットワーク」「プラン」「コントローラ」「スコアリング」「リプランニング（経路再探索）」の各モジュール設定から構成されている。

1. global モジュール

• シミュレーションの乱数シード（4711）を指定して再現性を確保している。

• 使用する座標系として EPSG:6685（日本の平面直角座標系 9系などに相当）を明示している。

2. network モジュール

• 交通ネットワークとして network.xml を読み込む設定である。

• 道路・リンク・ノード等の空間構造を定義する基礎データである。

3. plans モジュール

• エージェントの活動計画ファイルとして plans100.xml を指定している。

• 各エージェントの1日の行動（自宅→職場など）を読み込む役割を持つ。

4. controller モジュール

• 出力ディレクトリを ./output とし、最終イテレーションは 10 としている。

• 各イテレーションでイベントファイル（events.xml.gz）を出力するため、writeEventsInterval=1 を設定している。

5. scoring モジュール

• スコア計算に関するパラメータを定義している。

  • 遅刻のペナルティ（lateArrival = −18）

  • 活動継続の効用（performing = +6）

• 活動タイプ h（home） および w（work） の典型滞在時間・開閉時間などを定義し、日常行動モデルの評価基準を与えている。

6. replanning モジュール

• プラン選択と経路再探索に関する戦略設定を行っている。

  • BestScore（重み 0.9）

  • ReRoute（重み 0.1）

• これにより、シミュレーション内でエージェントがプランを修正し、より良い経路や活動を選択する過程を再現する。

総括

本 config.xml は、標準的な MATSim 実行構成を踏襲しながら、日本の座標系（EPSG:6685）を用いたネットワーク・プランデータを読み込み、10 イテレーションのシミュレーションを行う設定となっている。スコアリングおよび再計画戦略も基本設定が施されており、小規模テストから実用的な解析まで広く利用可能な構成である。

[network.xml]

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE network SYSTEM "http://www.matsim.org/files/dtd/network_v1.dtd">

<network name="equil test network">
  <nodes>
	<node id="1"  x="774558.033" y="1108851.844"/>
	<node id="2"  x="779558.033" y="1108851.844"/>
	<node id="3"  x="793693.033" y="1114776.844"/>
	<node id="4"  x="792060.033" y="1113182.844"/>
	<node id="5"  x="790729.033" y="1112066.844"/>
	<node id="6"  x="789860.033" y="1110562.844"/>
	<node id="7"  x="789558.033" y="1108851.844"/>
	<node id="8"  x="789860.033" y="1107140.844"/>
	<node id="9"  x="790729.033" y="1105636.844"/>
	<node id="10" x="792060.033" y="1104520.844"/>
	<node id="11" x="793693.033" y="1102926.844"/>
	<node id="12" x="794558.033" y="1108851.844"/>
	<node id="13" x="799558.033" y="1108851.844"/>
	<node id="14" x="799558.033" y="1098851.844"/>
	<node id="15" x="774558.033" y="1098851.844"/>
  </nodes>

   <links capperiod="01:00:00">
      <link id="1" from="1" to="2" length="10000.00" capacity="36000" freespeed="27.78" permlanes="1"  />
      <link id="2" from="2" to="3" length="10000.00" capacity="3600" freespeed="27.78" permlanes="1"  />
      <link id="3" from="2" to="4" length="10000.00" capacity="3600" freespeed="27.78" permlanes="1"  />
      <link id="4" from="2" to="5" length="10000.00" capacity="3600" freespeed="27.78" permlanes="1"  />
      <link id="5" from="2" to="6" length="10000.00" capacity="3600" freespeed="27.78" permlanes="1"  />
      <link id="6" from="2" to="7" length="10000.00" capacity="3600" freespeed="27.78" permlanes="1"  />
      <link id="7" from="2" to="8" length="10000.00" capacity="3600" freespeed="27.78" permlanes="1"  />
      <link id="8" from="2" to="9" length="10000.00" capacity="3600" freespeed="27.78" permlanes="1"  />
      <link id="9" from="2" to="10" length="10000.00" capacity="3600" freespeed="27.78" permlanes="1"  />
      <link id="10" from="2" to="11" length="10000.00" capacity="3600" freespeed="27.78" permlanes="1"  />
      <link id="11" from="3" to="12" length="5000.00" capacity="1000" freespeed="27.78" permlanes="1"  />
      <link id="12" from="4" to="12" length="5000.00" capacity="1000" freespeed="27.78" permlanes="1"  />
      <link id="13" from="5" to="12" length="5000.00" capacity="1000" freespeed="27.78" permlanes="1"  />
      <link id="14" from="6" to="12" length="5000.00" capacity="1000" freespeed="27.78" permlanes="1"  />
      <link id="15" from="7" to="12" length="5000.00" capacity="1000" freespeed="27.78" permlanes="1"  />
      <link id="16" from="8" to="12" length="5000.00" capacity="1000" freespeed="27.78" permlanes="1"  />
      <link id="17" from="9" to="12" length="5000.00" capacity="1000" freespeed="27.78" permlanes="1"  />
      <link id="18" from="10" to="12" length="5000.00" capacity="1000" freespeed="27.78" permlanes="1"  />
      <link id="19" from="11" to="12" length="5000.00" capacity="1000" freespeed="27.78" permlanes="1"  />
      <link id="20" from="12" to="13" length="10000.00" capacity="36000" freespeed="27.78" permlanes="1"  />
      <link id="21" from="13" to="14" length="10000.00" capacity="36000" freespeed="27.78" permlanes="1"  />
      <link id="22" from="14" to="15" length="35000.00" capacity="36000" freespeed="27.78" permlanes="1"  />
      <link id="23" from="15" to="1" length="10000.00" capacity="36000" freespeed="27.78" permlanes="1"  />
   </links>
</network>

network.xml の概要

本 network.xml は、MATSim の「equil（equilibrium）」テストで用いられる代表的な小規模ネットワークの構造を記述したものであり、ノード 15 点とリンク 23 本から構成される。全体として、中央ノード「2」を中心とした放射状構造と、外周を囲うリング構造をあわせ持つネットワークである。

1. ノード構成（nodes）

• ノード数は 15。

• 座標はメートル単位の **平面直角座標（UTM ではない独自座標）**に近い配置。

• ノード 1 → 2 → 3 → 12 → 13 → 14 → 15 → 1 と接続する大きな「外周ループ（リング）」が形成されている。

■ 中央に位置するノード

• ノード 2
  → このノードから計 10 本のリンクが放射状に伸びており、ネットワークの「ハブ」として機能する。

■ 外周ノード

• 1, 2, 3, 12, 13, 14, 15
  → 大きな四角形〜多角形を構成する外周ノード。

■ 放射状ノード

• 3〜11（2 を中心とした扇状配置）

• これらのノードはすべてノード 12 に接続され、中央から外周へ向かう“枝”のような構造を形成。

2. リンク構成（links）

総リンク数は 23 本。時間帯は capperiod="01:00:00"（1時間あたり容量）。

(1) ハブ（ノード 2）から放射状に伸びるリンク（リンクID 2〜10）

• from="2" → to="3〜11"

• 長さ：10,000 m

• 容量：3,600 veh/h

• 自由速度：27.78 m/s（= 約 100 km/h）

• 構造：中央ノードから各方向へ伸びる 9 本の支線

(2) 放射状ノードからノード 12 への接続（リンクID 11〜19）

• 各ノード 3〜11 → ノード 12 へ接続

• 長さ：5,000 m

• 容量：1,000 veh/h（細い道路）

• 放射状ネットワークの外周に向かう“枝”の集約点がノード 12

(3) 外周ループ（リンクID 1, 20〜23）

• 1 → 2

• 12 → 13

• 13 → 14

• 14 → 15

• 15 → 1

• 長さ：10,000〜35,000 m

• 容量：36,000 veh/h（高速道路レベル）

• ネットワーク外周を広く囲むリング道路

3. ネットワーク構造の特徴

• 中央ハブ（ノード2）
  → 多方向に交通が流れる主要結節点。
  → エージェントが多く集まるため、MATSim チュートリアルで典型的に渋滞が再現される部分。

• 外周大容量リンク
  → 大容量（36,000 veh/h）で構成され、混雑しづらい。
  → “外環状道路”として機能。

• 中間のノード 12 が集約点
  → 放射状ノード群の出口に相当。
  → ハブ（2）と外周（13）を結ぶ重要な中継ノード。

• 典型的なテストネットワーク
  → シンプルであるが、渋滞・ルート選択・再探索の動きを明確に確認できる構造。
  → MATSim の初学者用・論文やサンプルコードで用いられる標準モデル。

総括

この network.xml は、MATSim の代表的な「equil」ネットワークをベースとしたもので、中心に交通が集中するハブ構造と、大容量リング道路、放射状道路からなるシンプルかつ典型的なテスト用ネットワークである。渋滞発生や再経路探索のような動態変化を観察するのに適した構成となっている。

[plans100.xml]

<?xml version="1.0" ?>
<!DOCTYPE plans SYSTEM "http://www.matsim.org/files/dtd/plans_v4.dtd">
<plans xml:lang="de-CH">
<person id="1">
	<plan>
		<act type="h" x="-25000" y="0" link="1" end_time="06:00" />
		<leg mode="car">
			<route>2 7 12</route>
		</leg>
		<act type="w" x="10000" y="0" link="20" dur="00:10" />
		<leg mode="car">
			<route> </route>
		</leg>
		<act type="w" x="10000" y="0" link="20" dur="03:30" />
		<leg mode="car">
			<route>13 14 15 1</route>
		</leg>
		<act type="h" x="-25000" y="0" link="1" />
	</plan>
</person>

</plans>

この概要は以下の通り。

plans100.xml の概要

この plans100.xml は、MATSim に投入する **エージェントの活動計画（1日の行動スケジュール）**を定義したファイルである。
現状では person は1名のみ（id="1"）であり、その人物が 自宅(h)→職場(w)→職場(w)→自宅(h) と移動しながら活動する1日の行動列が記述されている。

1. person と plan の構成

• <person id="1">
  → エージェント1名を定義。

• <plan>
  → そのエージェントの1日の行動計画を時系列に並べる。
  act（活動）と leg（移動）の交互列が基本。

2. 行動列の中身（act / leg）

(1) 自宅活動 h

• type="h" は home（自宅）。

• link="1" 上に存在する活動地点。

• end_time="06:00" なので、06:00 に出発する設定。

(2) 車移動（自宅→職場）

• mode="car" により車移動。

• route は通過リンク列で、
  リンク 2 → 7 → 12 を通る経路を明示している。

(3) 職場活動 w（短い滞在）

• type="w" は work（職場）。

• link="20" 上で活動。

• dur="00:10" なので 10分だけ職場に滞在。

(4) 車移動（職場→職場）

• 車移動だが route が空白。

• これは 経路をMATSim側に再計算させる意図で置かれていると解釈できる。

(5) 職場活動 w（長い滞在）

• 同じ link="20" の職場で、
  3時間30分滞在する設定。

(6) 車移動（職場→自宅）

• リンク 13 → 14 → 15 → 1 を通って帰宅する経路が明示されている。

• ネットワークの外周ループ側を通る帰路と対応する。

(7) 自宅活動 h（帰宅後）

• 最終活動は自宅(h)。

• end_time や dur がないため、**その時点で計画終了（終日滞在）**の意味。

3. この plans.xml の特徴と用途

• person が1名だけの 最小構成テスト用 plans。

• 経路が一部手動指定、一部自動再探索（空 route）という混合設定。

• equil ネットワーク上で
  時間指定付きの通勤行動と、再経路探索の挙動を確認するための計画になっている。

総括

plans100.xml は、エージェント1名の1日行動（06:00 出発の通勤、職場での短時間/長時間滞在、外周経路で帰宅）を記述したテスト用 plans である。経路指定を明示する部分と MATSim に任せる部分が共存しており、ルート選択やリプランニングの動作確認に適した構成となっている。

さて、3つのファイルで

ebata@DESKTOP-1QS7OI7:~/matsim-example-project/scenarios/equil2/output$ ls
ITERS                      modestats.png              output_households.xml.gz  pkm_modestats.csv
logfile.log                modestats_stackedbar.png   output_legs.csv.gz        pkm_modestats.png
logfileWarningsErrors.log  modules.dot                output_links.csv.gz       scorestats.csv
modeChoiceCoverage10x.png  output_activities.csv.gz   output_network.xml.gz     scorestats.png
modeChoiceCoverage10x.txt  output_allVehicles.xml.gz  output_persons.csv.gz     stopwatch.csv
modeChoiceCoverage1x.png   output_config.xml          output_plans.xml.gz       stopwatch.png
modeChoiceCoverage1x.txt   output_config_reduced.xml  output_trips.csv.gz       tmp
modeChoiceCoverage5x.png   output_counts.xml.gz       output_vehicles.xml.gz    traveldistancestats.csv
modeChoiceCoverage5x.txt   output_events.xml.gz       ph_modestats.csv          traveldistancestatslegs.png
modestats.csv              output_facilities.xml.gz   ph_modestats.png          traveldistancestatstrips.png
ebata@DESKTOP-1QS7OI7:~/matsim-example-project/scenarios/equil2/output$

ができている。

ここにcsvファイル作成用のPythonプログラム(matsim_events_to_csv.py)を書き込む。

[matsim_events_to_csv.py]

import gzip
import xml.etree.ElementTree as ET
import csv
import math

EVENTS_FILE = "output_events.xml.gz"
NETWORK_FILE = "output_network.xml.gz"
OUT_CSV = "agents_positions.csv"
STEP_SEC = 1.0  # 1秒刻み


def load_network(network_file):
    nodes = {}
    links = {}

    with gzip.open(network_file, 'rb') as f:
        tree = ET.parse(f)
        root = tree.getroot()

        for node in root.find("nodes"):
            nid = node.attrib["id"]
            x = float(node.attrib["x"])
            y = float(node.attrib["y"])
            nodes[nid] = (x, y)

        for link in root.find("links"):
            lid = link.attrib["id"]
            fnode = link.attrib["from"]
            tnode = link.attrib["to"]
            length = float(link.attrib.get("length", "0"))
            freespeed = float(link.attrib.get("freespeed", "0"))
            links[lid] = (fnode, tnode, length, freespeed)

    return nodes, links


def interpolate_points(t0, t1, x0, y0, x1, y1, step=1.0):
    dt = t1 - t0
    if dt <= 0:
        return [(t0, x0, y0), (t1, x1, y1)]

    n_steps = int(math.floor(dt / step))
    pts = []

    for i in range(n_steps + 1):
        t = t0 + i * step
        if t > t1:
            break
        r = (t - t0) / dt
        x = x0 + r * (x1 - x0)
        y = y0 + r * (y1 - y0)
        pts.append((t, x, y))

    if not pts or pts[-1][0] < t1:
        pts.append((t1, x1, y1))

    return pts


def process_events(events_file, nodes, links, out_csv):
    # vehicle -> person 対応
    vehicle_to_person = {}

    # vehicleごとの entered 状態
    # in_progress[vehicle] = (link_id, enter_time)
    in_progress = {}

    with gzip.open(events_file, 'rb') as f, open(out_csv, "w", newline="", encoding="utf-8") as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow(["time", "person", "x", "y", "link", "event_type"])

        for ev, elem in ET.iterparse(f, events=("end",)):
            if elem.tag != "event":
                continue

            a = elem.attrib
            etype = a.get("type", "")
            time = float(a.get("time", "0"))

            # 1) vehicle -> person 対応を作る
            if etype == "PersonEntersVehicle":
                person = a.get("person")
                vehicle = a.get("vehicle")
                if person and vehicle:
                    vehicle_to_person[vehicle] = person
                elem.clear()
                continue

            # 2) entered/left link は vehicle 単位で処理
            if etype in ("entered link", "left link"):
                vehicle = a.get("vehicle")
                link_id = a.get("link")
                if vehicle is None or link_id is None:
                    elem.clear()
                    continue
                if link_id not in links:
                    elem.clear()
                    continue
                if vehicle not in vehicle_to_person:
                    # person がまだ紐付いていない車両は無視
                    elem.clear()
                    continue

                fnode, tnode, length, freespeed = links[link_id]
                if fnode not in nodes or tnode not in nodes:
                    elem.clear()
                    continue

                if etype == "entered link":
                    in_progress[vehicle] = (link_id, time)

                elif etype == "left link":
                    if vehicle not in in_progress:
                        elem.clear()
                        continue

                    entered_link_id, t_enter = in_progress[vehicle]
                    if entered_link_id != link_id:
                        # 不整合対策：状態を更新してスキップ
                        in_progress[vehicle] = (link_id, time)
                        elem.clear()
                        continue

                    t_left = time
                    actual_dt = t_left - t_enter

                    expected_dt = length / freespeed if freespeed > 0 and length > 0 else None
                    if actual_dt <= 0:
                        if expected_dt is not None and expected_dt > 0:
                            actual_dt = expected_dt
                            t_left = t_enter + actual_dt
                        else:
                            actual_dt = 0

                    x0, y0 = nodes[fnode]
                    x1, y1 = nodes[tnode]

                    pts = interpolate_points(t_enter, t_left, x0, y0, x1, y1, step=STEP_SEC)

                    person = vehicle_to_person[vehicle]
                    for t, x, y in pts:
                        writer.writerow([t, person, x, y, link_id, "move"])

                    in_progress.pop(vehicle, None)

            elem.clear()


def main():
    nodes, links = load_network(NETWORK_FILE)
    process_events(EVENTS_FILE, nodes, links, OUT_CSV)
    print(f"CSV exported: {OUT_CSV}")


if __name__ == "__main__":
    main()

$ebata@DESKTOP-1QS7OI7:~/matsim-example-project/scenarios/equil2/output$ python matsim_events_to_csv.py
CSV exported: agents_positions.csv

このagents_positions.csvが、エージェントの軌跡となるが、面倒なので、時間と座標を出すプログラムを作成

[matsim_events_to_geo_csv.py]

import gzip
import xml.etree.ElementTree as ET
import csv
import math
from datetime import datetime, timedelta, timezone

try:
    from pyproj import Transformer
except ImportError as e:
    raise SystemExit(
        "pyproj が必要です。pip install pyproj を実行してください。"
    )

EVENTS_FILE = "output_events.xml.gz"
NETWORK_FILE = "output_network.xml.gz"
OUT_CSV = "agents_positions_geo.csv"
STEP_SEC = 1.0  # 1秒刻み

# シミュレーション開始日時（必要に応じて変更）
# 例: 日本時間で 2025-11-24 00:00:00 開始
SIM_START = datetime(2025, 11, 24, 0, 0, 0, tzinfo=timezone(timedelta(hours=9)))

# 座標変換: EPSG:6685 -> EPSG:4326 (lon, lat)
TRANSFORMER = Transformer.from_crs("EPSG:6685", "EPSG:4326", always_xy=True)


def load_network(network_file):
    nodes = {}
    links = {}

    with gzip.open(network_file, 'rb') as f:
        tree = ET.parse(f)
        root = tree.getroot()

        for node in root.find("nodes"):
            nid = node.attrib["id"]
            x = float(node.attrib["x"])
            y = float(node.attrib["y"])
            nodes[nid] = (x, y)

        for link in root.find("links"):
            lid = link.attrib["id"]
            fnode = link.attrib["from"]
            tnode = link.attrib["to"]
            length = float(link.attrib.get("length", "0"))
            freespeed = float(link.attrib.get("freespeed", "0"))
            links[lid] = (fnode, tnode, length, freespeed)

    return nodes, links


def interpolate_points(t0, t1, x0, y0, x1, y1, step=1.0):
    dt = t1 - t0
    if dt <= 0:
        return [(t0, x0, y0), (t1, x1, y1)]

    n_steps = int(math.floor(dt / step))
    pts = []

    for i in range(n_steps + 1):
        t = t0 + i * step
        if t > t1:
            break
        r = (t - t0) / dt
        x = x0 + r * (x1 - x0)
        y = y0 + r * (y1 - y0)
        pts.append((t, x, y))

    if not pts or pts[-1][0] < t1:
        pts.append((t1, x1, y1))

    return pts

def sec_to_datetime_str(sec):
    dt = SIM_START + timedelta(seconds=sec)
    # QGISで扱いやすい形式 → 2025-11-24 06:00:01
    return dt.strftime('%Y-%m-%d %H:%M:%S')

def xy_to_lonlat(x, y):
    lon, lat = TRANSFORMER.transform(x, y)
    return lon, lat


def process_events(events_file, nodes, links, out_csv):
    vehicle_to_person = {}
    in_progress = {}

    with gzip.open(events_file, 'rb') as f, open(out_csv, "w", newline="", encoding="utf-8") as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow(["datetime", "time_sec", "person", "lat", "lon", "link", "event_type"])

        for ev, elem in ET.iterparse(f, events=("end",)):
            if elem.tag != "event":
                continue

            a = elem.attrib
            etype = a.get("type", "")
            time_sec = float(a.get("time", "0"))

            # vehicle -> person 対応付け
            if etype == "PersonEntersVehicle":
                person = a.get("person")
                vehicle = a.get("vehicle")
                if person and vehicle:
                    vehicle_to_person[vehicle] = person
                elem.clear()
                continue

            if etype in ("entered link", "left link"):
                vehicle = a.get("vehicle")
                link_id = a.get("link")
                if vehicle is None or link_id is None:
                    elem.clear()
                    continue
                if link_id not in links:
                    elem.clear()
                    continue
                if vehicle not in vehicle_to_person:
                    elem.clear()
                    continue

                fnode, tnode, length, freespeed = links[link_id]
                if fnode not in nodes or tnode not in nodes:
                    elem.clear()
                    continue

                if etype == "entered link":
                    in_progress[vehicle] = (link_id, time_sec)

                elif etype == "left link":
                    if vehicle not in in_progress:
                        elem.clear()
                        continue

                    entered_link_id, t_enter = in_progress[vehicle]
                    if entered_link_id != link_id:
                        in_progress[vehicle] = (link_id, time_sec)
                        elem.clear()
                        continue

                    t_left = time_sec
                    actual_dt = t_left - t_enter

                    expected_dt = length / freespeed if freespeed > 0 and length > 0 else None
                    if actual_dt <= 0:
                        if expected_dt is not None and expected_dt > 0:
                            actual_dt = expected_dt
                            t_left = t_enter + actual_dt
                        else:
                            actual_dt = 0

                    x0, y0 = nodes[fnode]
                    x1, y1 = nodes[tnode]

                    pts = interpolate_points(t_enter, t_left, x0, y0, x1, y1, step=STEP_SEC)

                    person = vehicle_to_person[vehicle]
                    for t, x, y in pts:
                        lon, lat = xy_to_lonlat(x, y)
                        dt_str = sec_to_datetime_str(t)
                        writer.writerow([dt_str, t, person, lat, lon, link_id, "move"])

                    in_progress.pop(vehicle, None)

            elem.clear()


def main():
    nodes, links = load_network(NETWORK_FILE)
    process_events(EVENTS_FILE, nodes, links, OUT_CSV)
    print(f"CSV exported: {OUT_CSV}")


if __name__ == "__main__":
    main()

QGISで動画表示する
レイヤ→属性テーブルを開く

これでdtというエントリーができる。
これで「プロパティ」→「時系列」で、

を投入する
これで
「プロジェクト」→「プロパティ」→「時系列」→「レイヤから計算」→「適用」

これもセットしないと出てこない

時系列コントロールを表示するには4つ設定しないと出てこない。
(1)そのレイヤ→"属性テーブル"によるdtのセット
(2)そのレイヤ→"プロパティ"によるセット
(3)メニューの"プロジェクト"→"プロパティ"→"時系列"によるセット
(4)メニューの"ビュー"→"パネル"→"時系列コントローラ"のチェック

こんな感じの動画がでます。

======

まず失敗から。

MATSim Docker image(https://github.com/maptic/matsim-docker)で動かせない。3日間くらいの時間を費やした結果、断念

-----

(1)WSLのUbuntuを起動

(2)matsim-example-project(https://github.com/matsim-org/matsim-example-project)にあるコンテンツをダウンロード

cd ~
git clone https://github.com/matsim-org/matsim-example-project.git

(3)ビルド

cd ~/matsim-example-project$

./mvnw clean package

(3-1) どの java が呼ばれているか確認

which -a java
readlink -f "$(which java)"
echo "$JAVA_HOME"
which -a で複数出たら、一番上が今使われている java です。

JAVA_HOME が 17 を指していれば、PATH 先頭に $JAVA_HOME/bin が来て 17 が優先されます。

~/.bashrc や ~/.profile に JAVA_HOME=/usr/lib/jvm/java-17... の行が残っていると、それが勝ちます。

(3-2) 一時的に 21 へ切り替え（すぐ試せます）

export JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64
export PATH="$JAVA_HOME/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
hash -r # シェルのコマンドキャッシュをクリア
java -version
→ ここで openjdk version "21..." になれば OK。

(3-3) 恒久設定（ログイン時に毎回 21 になるように）

~/.bashrc または ~/.profile の中の 古い JAVA_HOME/PATH 行をコメントアウトし、下を追記：

# Java 21 を既定にする
export JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64
export PATH="$JAVA_HOME/bin:$PATH"

保存後、反映：

exec $SHELL -l
java -version

(4)MATSim起動

cd ~/matsim-example-project$

java -jar matsim-example-project-0.0.1-SNAPSHOT.jar

(4)テスト起動

「Choose」を押す → リポジトリ内の
scenarios/equil/config.xml を選択。

ちなみに、Output Directoryのは、自動的に、
/home/ebata/matsim-example-project/scenarios/equil/output
が入っていた。

「Start MATSim」のボタンを押下

2～3分後に、こんな感じになった

コンソール画面も、こんな感じになって、入力できない状況

ただ、この段階で、データはできているので、コンソールをCtrl-Cで落しても良い。

で、ここから図示したかったのですが、すったもんだしたあげく失敗したので、via-appを使うようにしました。

で、WSLのUbuntuで、以下からダンロードします。

https://simunto.com/via/download

で、

$CPU=$(dpkg --print-architecture)
$wget https://www.simunto.com/data/via/release/debian/simunto-via-app_25.1.0_${CPU}.deb
$sudo apt install ./simunto-via-app_25.1.0_${CPU}.deb

を実施すると、

$via-app

で、viaが起動します。

ebata@DESKTOP-1QS7OI7:~/matsim-example-project$ export DISPLAY=:0
ebata@DESKTOP-1QS7OI7:~/matsim-example-project$ export LIBGL_ALWAYS_INDIRECT=1

ebata@DESKTOP-1QS7OI7:~/via-app

も必要かもしれない。

"output_network.xml.gz"を選択

同じ様に、

"output_events.xml.gz"

を選択する。

上図のように、"Load Data"ボタンを押して下さい。

上図のようにタイムラインが表示され、08:00から数分間のみ、自動車が表示されます。右側のインジケータを若干右に移動させると、移動の様子(といっても表われて消えているだけの様子)が見えます。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE config SYSTEM "http://www.matsim.org/files/dtd/config_v2.dtd">
<config>
  <module name="controller">
    <param name="firstIteration" value="0"/>
    <param name="lastIteration"  value="0"/>
    <param name="overwriteFiles" value="overwriteExistingFiles"/>
    <param name="outputDirectory" value="output/simple1"/>
  </module>

  <module name="network">
    <param name="inputNetworkFile" value="network.xml"/>
  </module>

  <module name="plans">
    <param name="inputPlansFile" value="plans.xml"/>
  </module>

  <module name="qsim">
    <param name="startTime" value="00:00:00"/>
    <param name="endTime"   value="24:00:00"/>
  </module>

  <!-- 旧 strategy → replanning に修正済み -->
  <module name="replanning">
    <param name="maxAgentPlanMemorySize" value="1"/>
  </module>

  <!-- scoring に h / w を定義 -->
  <module name="scoring">
    <parameterset type="activityParams">
      <param name="activityType" value="h"/>
      <param name="typicalDuration" value="12:00:00"/>
    </parameterset>
    <parameterset type="activityParams">
      <param name="activityType" value="w"/>
      <param name="typicalDuration" value="08:00:00"/>
      <param name="openingTime" value="07:00:00"/>
      <param name="closingTime" value="18:00:00"/>
    </parameterset>
  </module>
</config>

この `config.xml` は、MATSim（Multi-Agent Transport Simulation）の実行設定を記述したファイルです。内容をセクションごとに整理すると次のようになります。

---

### 1. `<module name="controller">`

シミュレーション全体の制御に関する設定。

* `firstIteration=0`
最初のイテレーション番号を 0 に設定。
* `lastIteration=0`
最後のイテレーションも 0 にしているので、学習や繰り返しは行わず、初期の状態のみを実行する（ワンショットのシミュレーション）。
* `overwriteFiles=overwriteExistingFiles`
出力ディレクトリに既存のファイルがあっても上書きする設定。
* `outputDirectory=output/simple1`
シミュレーション結果の出力先フォルダ。

---

### 2. `<module name="network">`

利用する交通ネットワークデータの指定。

* `inputNetworkFile=network.xml`
道路やリンク構造が記載されたネットワーク定義ファイル。

---

### 3. `<module name="plans">`

エージェント（個人）の行動計画データの指定。

* `inputPlansFile=plans.xml`
各エージェントの出発地・目的地・活動スケジュールを記載したプランファイル。

---

### 4. `<module name="qsim">`

シミュレーション実行時間の設定。

* `startTime=00:00:00`
シミュレーション開始時刻を午前 0 時に設定。
* `endTime=24:00:00`
シミュレーション終了時刻を 24 時に設定（丸一日分を対象にする）。

---

### 5. `<module name="replanning">`

プラン修正（replanning）の設定。
※旧名称 `strategy` が `replanning` に変更されたもの。

* `maxAgentPlanMemorySize=1`
各エージェントが保持できるプランの数を 1 に制限（つまり再計画はせず、最初のプランをそのまま利用）。

---

### 6. `<module name="scoring">`

エージェントが行動を評価するためのスコアリング設定。ここでは活動（activity）のパラメータを定義している。

* `activityType=h`
「h」（home、自宅滞在）活動を 12 時間の典型的持続時間で設定。
* `activityType=w`
「w」（work、仕事）活動を 8 時間の典型的持続時間で設定。
また、開店時間を 7:00、閉店時間を 18:00 とすることで、仕事に従事できる時間帯の制約を表現。

---

### 総合説明

この設定ファイルは、**1日分の単発シミュレーション**を対象とし、ネットワークとプランデータを与え、再計画を行わずに実行するシンプルなケースを記述している。活動は「自宅（h）」と「仕事（w）」の2種類のみで、典型的な1日の行動（12時間の在宅と8時間の勤務）を再現する構成になっている。

---

?? 要するに、この `config.xml` は \*\*「network.xml」と「plans.xml」を入力として、エージェントが自宅と仕事の往復を行う1日シミュレーションを出力/simple1 に結果保存する」\*\*ための設定ファイルです。

[config.xml]

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE network SYSTEM "http://www.matsim.org/files/dtd/network_v2.dtd">
<network name="tiny-net">
  <nodes>
    <node id="1" x="0.0"    y="0.0"/>
    <node id="2" x="1000.0" y="0.0"/>
  </nodes>

  <links>
    <!-- 1km、自由速度15m/s ≒ 54km/h、容量 1000veh/h、1車線 -->
    <link id="1_2" from="1" to="2" length="1000.0" freespeed="15.0"
          capacity="1000.0" permlanes="1" modes="car"/>
    <link id="2_1" from="2" to="1" length="1000.0" freespeed="15.0"
          capacity="1000.0" permlanes="1" modes="car"/>
  </links>
</network>

この `network.xml` は、MATSim で利用する交通ネットワークを記述したファイルで、最小限の「2ノード・2リンク」からなる非常にシンプルなネットワークを定義しています。内容を整理すると以下の通りです。

---

### 1. `<network name="tiny-net">`

ネットワーク全体の名前として `"tiny-net"` を定義。小規模なテスト用ネットワークであることを示す。

---

### 2. `<nodes>`

ノード（交差点や地点）を定義。ここでは2つのノードがある。

* `<node id="1" x="0.0" y="0.0"/>`
座標 (0,0) にあるノード。IDは `1`。
* `<node id="2" x="1000.0" y="0.0"/>`
座標 (1000,0) にあるノード。IDは `2`。
→ ノード間は直線で 1000m（=1km）離れている。

---

### 3. `<links>`

ノード間を結ぶリンク（道路）を定義。2本のリンクが双方向に設定されている。

* `<link id="1_2" from="1" to="2" ... />`
ノード1からノード2へ向かうリンク。

* 長さ：`1000.0` m （1km）
* 自由速度：`15.0` m/s ≒ 54 km/h
* 容量：`1000.0` 台/時 （1時間あたりの通過可能車両数）
* 車線数：`1`
* 利用可能モード：`car` のみ
* `<link id="2_1" from="2" to="1" ... />`
ノード2からノード1へ戻るリンク。条件は上記と同じ。

---

### まとめ

このファイルは、**1kmの直線道路を2ノードで表現し、車が双方向に走行できるようにした最小限の道路ネットワーク**を定義している。速度や容量も現実的な数値（片側1車線、時速54km、1000台/時）で設定されており、テストや学習用のシミュレーションに適したネットワーク構成になっている。

?? 要するに「**ノード1とノード2を結ぶ片側1車線の道路（往復2車線）だけのシンプルネットワーク**」です。

[plans.xml]

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plans SYSTEM "http://www.matsim.org/files/dtd/plans_v4.dtd">
<plans>
  <person id="1">
    <plan selected="yes">
      <act type="h" link="1_2" x="0.0" y="0.0" end_time="08:00:00"/>
      <leg mode="car"/>
      <act type="w" link="2_1" x="1000.0" y="0.0" end_time="17:00:00"/>
      <leg mode="car"/>
      <act type="h" link="1_2" x="0.0" y="0.0"/>
    </plan>
  </person>
</plans>

この `plans.xml` は、MATSim におけるエージェント（人物）の行動計画を記述したファイルです。内容を整理すると以下のようになります。

---

### 1. `<plans>` ルート要素

計画ファイル全体を示すルート。内部に個々の人物（`<person>`）とその行動計画（`<plan>`）を記述。

---

### 2. `<person id="1">`

ID が `1` の人物を定義。ここでは 1 人だけ。

---

### 3. `<plan selected="yes">`

この人物の計画（行動スケジュール）を記述。

* `selected="yes"` → このプランが実行対象として選択されている。

---

### 4. 行動と移動の流れ

計画は **行動（`<act>`）と移動（`<leg>`）が交互に記述**される。ここでは1日の典型的な「自宅→仕事→自宅」往復を表現している。

#### (1) 自宅での行動

```xml
<act type="h" link="1_2" x="0.0" y="0.0" end_time="08:00:00"/>
```

* `type="h"`：自宅（home）活動。
* `link="1_2"`：ノード1→2のリンク上に自宅があると仮定。
* 座標 `(0.0, 0.0)`（ノード1の位置に対応）。
* `end_time="08:00:00"` → 午前8時まで自宅に滞在し、その後移動を開始。

#### (2) 通勤移動

```xml
<leg mode="car"/>
```

* `mode="car"` → 自動車で移動する。
* 出発地点は自宅（link="1\_2"）、目的地は次の `<act>` で指定。

#### (3) 仕事での行動

```xml
<act type="w" link="2_1" x="1000.0" y="0.0" end_time="17:00:00"/>
```

* `type="w"`：仕事（work）活動。
* `link="2_1"`：ノード2→1のリンク上に職場があると仮定。
* 座標 `(1000.0, 0.0)`（ノード2の位置に対応）。
* `end_time="17:00:00"` → 午後5時まで仕事をして、その後帰宅移動。

#### (4) 帰宅移動

```xml
<leg mode="car"/>
```

* 仕事先から自動車で自宅へ戻る。

#### (5) 自宅での行動（帰宅後）

```xml
<act type="h" link="1_2" x="0.0" y="0.0"/>
```

* 再び自宅（link="1\_2"）で活動。
* 終了時刻は未設定なので、そのまま夜間～翌日まで滞在。

---

### まとめ

この `plans.xml` は、**1人の人物（id=1）が「午前8時に自宅を出発 → 車で職場へ通勤 → 午後5時まで勤務 → 車で帰宅 → 以降は自宅で滞在」する一日の行動計画**を記述している。

ネットワーク（`network.xml`）と組み合わせると、ノード1（自宅）とノード2（職場）の間を往復する最小限の通勤シナリオが再現できる構成になっている。

---

kno

以下のMATSimのplans.xmlの内容を説明して下さい。

<?xml version="1.0" ?>
<!DOCTYPE plans SYSTEM "http://www.matsim.org/files/dtd/plans_v4.dtd">
<plans xml:lang="de-CH">
  <person id="1">
	<plan>
      <act type="h" link="1" end_time="06:00" />
      <leg mode="car">
      </leg>
  
      <act type="w" link="10" dur="00:00:10" />
      <leg mode="walk">
      </leg>
	  
      <act type="w" link="11" dur="00:00:05" />
	  
      <leg mode="car">
		<!-- ここは書かない（MATSim に任せる） -->
      </leg>
	  
      <act type="h" link="11" />
	</plan>
  </person>

  <person id="2">
	<plan>
      <act type="h" link="10" end_time="06:00" />
      <leg mode="car">
		<route> </route>
      </leg>
	  
      <act type="w" link="11" dur="00:00:10" />
	  
      <leg mode="walk">
		<route> </route>
      </leg>
	  
      <act type="w" link="100" dur="00:00:05" />
	  
      <leg mode="car">
		<!-- ここは書かない（MATSim に任せる） -->
      </leg>
	  
      <act type="h" link="11" />
	</plan>
  </person>


</plans>

以下は、提示された MATSim の plans.xml の内容を、構造・意味・挙動の3点から整理して説明する。

1. ファイル全体の位置づけ

<!DOCTYPE plans SYSTEM "http://www.matsim.org/files/dtd/plans_v4.dtd">
<plans xml:lang="de-CH">

<person id="X">
  <plan>
    <act ... />
    <leg mode="..." />
    <act ... />
    ...
  </plan>
</person>

• person
  → エージェント（個人）

• plan
  → その人の1日の行動シーケンス

• act（activity）
  → 滞在行動（自宅、職場など）

• leg
  → 活動間の移動

• act と leg は必ず交互に出現する

3. person id="1" の行動計画

(1) 最初の自宅活動

<act type="h" link="1" end_time="06:00" />

• type="h"
  → home（自宅）

• link="1"
  → network.xml の link id=1 上で活動

• end_time="06:00"
  → 06:00 に出発

(2) 自宅 → 職場（車）

<leg mode="car">
</leg>

• 移動手段：car

• <route> が書かれていない
  → MATSim が network.xml と travel time を使って経路を自動生成

(3) 職場活動①

<act type="w" link="10" dur="00:00:10" />

• type="w"：work（職場）

• link="10"

• dur="00:00:10"
  → 10秒だけ滞在

• end_time ではなく dur が指定されている点に注意
  → 開始時刻＋滞在時間で終了時刻が決まる

(4) 徒歩移動

<leg mode="walk">
</leg>

• 徒歩移動

• 経路は MATSim が内部で処理
  （多くの場合、距離÷歩行速度の単純計算）

(5) 職場活動②（短時間）

<act type="w" link="11" dur="00:00:05" />

• 別リンク（11）での職場活動

• 滞在時間は 5秒

(6) 再び車移動（経路指定なし）

<leg mode="car">
  <!-- ここは書かない（MATSim に任せる） -->
</leg>

• 車移動

• 経路は再計算対象

• replanning が有効なら、反復ごとに経路が変わりうる

(7) 帰宅

<act type="h" link="11" />

• 自宅活動（終了時刻なし）

• シミュレーション終了まで滞在

4. person id="2" の行動計画の特徴

person 2 は、person 1 と似ているが、route タグが明示的に存在する点が重要。

(1) 車移動（空の route）

<leg mode="car">
  <route> </route>
</leg>

• <route> タグは存在するが中身は空

• この場合：

  • 初期状態では意味のある経路情報はない

  • MATSim は 初回の routing で上書きする

• 実質的には <route> を書かない場合とほぼ同等

(2) 徒歩移動（空 route）

<leg mode="walk">
  <route> </route>
</leg>

• 徒歩でも route を書けるが、

  • 多くのケースで MATSim は 詳細なリンク列を保持しない

  • travel time は内部計算

(3) 行動リンクの違い

<act type="w" link="100" dur="00:00:05" />

• person 1 とは異なるリンク構成

• network 上での空間的な差異を与えている

5. この plans.xml が意味する「本質」

(1) これは OD を完全に固定した計画ではない

• 出発時刻・滞在時間・モードは指定されている

• しかし：

  • 経路（link 列）は未確定

  • travel time はシミュレーション中に決定

(2) walk leg の扱い

• 多くの場合：

  • network を厳密に辿らない

  • link ベースの距離計算 or 直線近似

• そのため：

  • 正確な歩行経路ログは events.xml に残らないことが多い

(3) RCM / 共時空間解析への影響

• act の link と time は明示されている
  → 滞在の共時性は評価可能

• leg（特に walk）の詳細な軌跡は失われやすい
  → 移動中の「出会い」解析には不向き

6. まとめ（要点）

• この plans.xml は
  「行動の骨格だけを与え、移動の詳細は MATSim に委ねる」 設計

• route を書かない／空にするのは一般的

• 車移動はネットワークに基づくが
  徒歩移動は簡略化される

• 接触機会を「活動滞在ベース」で評価する用途向き

• 移動中の微細な接触解析には構造的制約がある

<attribute name="type" class="java.lang.String">residential</attribute> <attribute name="type" class="java.lang.String">primary</attribute> <attribute name="type" class="java.lang.String">tertiary</attribute> のアトリビュートの種類について説明をお願いします。
また、 <link id="203" from="1806698497" to="1806698523" length="159.5139984301562" freespeed="11.11111111111111" capacity="1000.0" permlanes="1.0" oneway="1" modes="car"> の各パラメータについても説明をお願いします。

以下、OSM → MATSim 変換後の network.xml を読むための実務向け説明として整理します。
定義論ではなく、「MATSim で何に使われ、どう効くか」を軸に書きます。

1. <attribute name="type"> とは何か

<attribute name="type" class="java.lang.String">residential</attribute>
<attribute name="type" class="java.lang.String">primary</attribute>
<attribute name="type" class="java.lang.String">tertiary</attribute>

結論

これは OSM の highway=* タグを、そのまま MATSim の link attribute として持ち込んだものです。

MATSim 標準の OsmNetworkReader は、

• OSM の highway タグ

• → MATSim link の attribute type

として保存します。

2. 各 type の意味（OSM 的・交通工学的）

以下は OSM の公式定義＋実務的な解釈です。

2.1 residential

• 住宅地内道路

• 生活道路

• 低速・低容量

• 交差点密度が高い

OSM 的には：

people live here

MATSim 的には：

• freespeed が低め

• capacity も控えめ

• 渋滞のボトルネックになりやすい

2.2 tertiary

• 地区幹線道路

• 住宅地と幹線をつなぐ役割

• 生活道路よりは速いが、主要幹線ではない

OSM 的には：

connects neighbourhoods

MATSim 的には：

• 中程度の freespeed

• 通過交通と生活交通が混在

2.3 primary

• 主要幹線道路

• 都市間・都市内の主要動脈

• 信号・交差点はあるが、通過交通向き

OSM 的には：

major roads between towns or important parts of a city

MATSim 的には：

• freespeed が高い

• capacity も高い

• 交通流を支配するリンクになりやすい

2.4 重要なポイント（研究用途的に）

• この type は MATSim の挙動に直接は使われない

• しかし：

  • 後処理

  • 可視化

  • フィルタリング

  • 分析（例：primary だけ抽出）

で 極めて重要

「MATSim が計算に使う値」ではなく
「人間が意味づけするための属性」

という位置づけです。

3. <link ...> 各パラメータの意味

対象：

<link id="203"
      from="1806698497"
      to="1806698523"
      length="159.5139984301562"
      freespeed="11.11111111111111"
      capacity="1000.0"
      permlanes="1.0"
      oneway="1"
      modes="car">

3.1 id="203"

• MATSim が内部的に振った link ID

• OSM の way ID ではない

• 識別子としてのみ使用

3.2 from, to

from="1806698497"
to="1806698523"

• MATSim network の node ID

• 今回は OSM node ID と一致

• 有向リンク（from → to）

3.3 length="159.51"

• リンク長 [m]

• CRS 変換後の座標距離から計算

• MATSim の移動時間・距離計算の基礎

重要：

• 現実の道路長と完全一致するとは限らない

• 曲線道路は直線近似されている

3.4 freespeed="11.11111111111111"

• 自由流速度 [m/s]

• 11.11 m/s ≒ 40 km/h

計算：

11.111... × 3.6 = 40 km/h

modes="car,bus"
modes="walk,bike"

4. MATSim 的に「効くパラメータ」「効かないパラメータ」

計算に直接効く

• length

• freespeed

• capacity

• permlanes

• modes

計算に直接は効かない（が超重要）

• attribute type（primary / residential など）

5. 全体の理解（重要）

この1本の link は、MATSim 的には：

「from node 1806698497 から to node 1806698523 へ
長さ約160m、自由流40km/h、容量1000veh/h、
車1車線の一方通行道路（住宅・幹線種別あり）」

という 完全に交通工学的な抽象道路です。

OSM の複雑な現実を、

• node

• directed link

• 数値パラメータ

に落とし込んだものが MATSim network です。

6. 次に自然な関心点

ここまで理解できたら、次は自然に：

• type ごとの freespeed / capacity の妥当性

• residential が速すぎないか？

• primary が遅すぎないか？

• bus を入れたらどう変わるか？

という **「モデルの現実性」**の話に進めます。

次はどこを見ますか？

• パラメータ調整？

• network の可視化？

• bus / pt network の追加？

network.xmlでは、全部、oneway="1"になっていますが、これで正しいのでしょうか？

結論から言います。

はい、現状の oneway="1" が並んでいるのは「異常ではない」が、
そのまま受け入れてよいかは「目的次第」です。

これは MATSim + OSM 変換で 非常によくある・意図された挙動です。
以下、理由と「何が起きているのか」を段階的に説明します。

1. まず重要な前提（誤解しやすい点）

❌ 誤解

OSM の道路は双方向が多い
→ network.xml も oneway="0" が多いはず

✅ 実際

MATSim の network は「有向リンク」が基本
→ 双方向道路でも「片方向リンク × 2本」で表現する

2. MATSim における「oneway」の意味

<link ... oneway="1" />

この oneway="1" は、

「この link オブジェクトは一方向リンクである」

という意味であり、

「この道路が現実世界で一方通行である」

という意味ではありません。

ここが最大の混乱ポイントです。

3. 双方向道路はどう表現されているか

OSM 側（例：residential, oneway 指定なし）

highway=residential
(oneway タグなし = 双方向)

MATSim 側では…

2本の link に分解されます

<link id="203" from="A" to="B" oneway="1" />
<link id="204" from="B" to="A" oneway="1" />

つまり：

👉 だから「全部 oneway=1」に見える

4. では「oneway=0」はいつ出るのか？

MATSim network では、実は：

• oneway="0" は ほぼ使われません

• 双方向性は link の本数で表現します

oneway="0" が出るケースは：

• 古い network

• 手書き network

• 特殊なカスタム実装

OSM → OsmNetworkReader → network.xml
という正統ルートでは、基本的に すべて oneway="1" になります。

5. OSM の oneway=yes はどう反映されているか

OSM が一方通行の場合

highway=primary
oneway=yes

MATSim では：

<link from="A" to="B" oneway="1" />

逆向きリンクは作られません

👉 結果として：

• 双方向道路：link が2本

• 一方通行道路：link が1本

どちらも oneway="1"

6. 正しいか？という問いへの答え

技術的に正しいか？

✅ 正しい

• MATSim の設計通り

• OsmNetworkReader の標準挙動

• 世界中の MATSim network がこうなっている

交通モデルとして正しいか？

✅ 目的次第で正しい

• 経路探索：問題なし

• 混雑生成：問題なし

• 方向制約：正しく表現されている

研究・説明的に誤解を招かないか？

⚠️ 説明は必要

論文・資料では必ずこう書くべきです：

「MATSim network は有向リンクで構成されており、
双方向道路は2本の一方向リンクとして表現されている」

7. 確認したい場合のチェック方法

(1) 同じ node ペアの逆向き link があるか

zgrep 'from="1806698497" to="1806698523"' output_network.xml.gz
zgrep 'from="1806698523" to="1806698497"' output_network.xml.gz

• 両方あれば → 双方向道路

• 片方だけ → 一方通行道路

8. まとめ（重要）

• oneway="1" が並ぶのは 正常

• MATSim は 有向リンク前提

• 双方向性は link の本数で表現

• OSM の oneway 情報は 逆向き link の有無に反映

• network.xml を見て不安になるのは 誰もが通る道

これはむしろ、

「network.xml をちゃんと読めている証拠」

です。

次に気になるのはたいてい：

• 「residential が速すぎないか？」

• 「capacity は現実的か？」

• 「bus を入れたらどうなるか？」

どれに進みますか？

network.xmlには、modes="car" になっています。エージェントで歩行をさせたい場合はどうすれば良いですか？

結論から言います。

いまの modes="car" の network.xml のままでは、歩行エージェントは動けません。
歩行をさせるには、network 側と設定（plans / config）の両方を整える必要があります。

以下、「何をどう変えるか」を 実務手順として説明します。

1. なぜ歩行できないのか（前提）

いまの network.xml では、各リンクが例えばこうなっています。

<link ... modes="car" />

MATSim の原則は：

エージェントは、自分の legMode が含まれるリンクしか通れない

つまり：

👉 歩行をさせるには、link に walk を含める必要がある

2. 方法は大きく3つある（重要）

方法A（最も正統・おすすめ）

network 作成時に walk を含める

あなたの Osm2NetworkCli は CLI で --modes を受け取れる構成です。

実行例

java -jar target/matsim-osm2network-1.0.0.jar \
  --osm hirohakama.osm \
  --out output_network.xml.gz \
  --toCRS EPSG:6685 \
  --modes car,walk

すると network.xml は：

<link ... modes="car,walk" />

になります。

✅ 車も歩行も同じ network を共有
✅ 最も MATSim 的
✅ 将来 bike / bus を足しやすい

方法B（歩行専用 network を作る）

--modes walk

• 歩行だけの network

• 車と完全に分離

これは：

• 歩行分析専用

• 車両流と干渉させたくない場合

に使います。

方法C（後処理で network.xml を書き換える）※非推奨

modes="car" → modes="car,walk"

を一括置換する方法。

❌ 再現性が低い
❌ 論文・研究向きでない
❌ 将来の自分が困る

3. network を直しただけでは「まだ足りない」

ここが重要ポイントです。

3.1 エージェント（plans.xml）側

歩行 leg はこうなっている必要があります。

<leg mode="walk">

3.2 config.xml 側（必須）

(1) qsim に walk を許可

<module name="qsim">
  <param name="mainModes" value="car,walk" />
</module>

(2) routing の設定

<module name="planscalcroute">
  <param name="networkModes" value="car,walk" />
</module>

(3) walk の速度（重要）

<module name="planscalcroute.walk">
  <param name="teleportedModeSpeed" value="1.34" />
</module>

※ 1.34 m/s ≒ 4.8 km/h（標準的歩行速度）

4. 歩行を「network 上で歩かせる」か「テレポート」にするか

MATSim では歩行に 2通りあります。

A. network walk（物理的にリンクを歩く）

• 渋滞・交差点を考慮

• 車と空間を共有

• 計算コスト高

👉 研究用途・都市スケール分析向き

B. teleported walk（距離÷速度）

• network を使わない

• 最短距離直線 or 軽量計算

• 計算コスト低

👉 大量人口・簡易分析向き

今の network を使うなら、あなたは A を選ぶ立場です。

5. 実務的なおすすめ手順（あなた向け）

① network を作り直す（最重要）

--modes car,walk

② config.xml に walk を追加

• qsim

• planscalcroute

• planscalcroute.walk

③ plans.xml に <leg mode="walk"> を入れる

6. まとめ（要点）

• modes="car" の network では歩行不可

• network 作成時に walk を含めるのが正道

• network / config / plans の3点セットが必要

• 歩行は MATSim では「特別扱い」されがちなので注意

• あなたの network 生成ツールは すでに walk 対応可能

Javaを使ったMATSim network.xml.gz 構築手順メモ（hirohakama）

1. 目的

OpenStreetMap から取得した OSM ファイルを入力として、
MATSim で利用可能な network.xml.gz を安定的・再現可能に生成する。

対象は以下。

• 入力：hirohakama.osm

• 出力：output_network.xml.gz

• 座標系：EPSG:6685（日本測地系・平面直角座標）

• 利用モード：car

2. なぜ Python プログラムではなく、MATSim 公式 API を使うのか

2.1 当初の疑問

• OSM → network 変換は Python でも書ける

• 実際、Python 版の変換スクリプトもすでに作成済み

• それでも MATSim の有効性を示すなら、公式ツールを使うべきではないか？ という疑問が生じた

2.2 結論

network.xml は「MATSim の内部仕様そのもの」であり、
MATSim 自身が生成した network.xml を使うことに意味がある

理由：

1. リンク属性（freespeed / capacity / lanes / allowedModes）の解釈が MATSim と完全一致

2. 将来 MATSim のバージョンが変わっても、
   network.xml の生成ロジックが MATSim 側で追従される

3. 論文・研究・再現性の観点で

   「MATSim 標準の OsmNetworkReader を用いて生成した network を使用した」
   と明記できる

結論として、

Python は補助・可視化・後処理に使う
network.xml の生成は MATSim に任せる

という役割分担にした。

3. 現在のディレクトリ構成（WSL）

/home/ebata/matsim-example-project/hirohakama/
├── hirohakama.osm
├── pom.xml
├── target/
│   ├── matsim-osm2network-1.0.0.jar
│   └── original-matsim-osm2network-1.0.0.jar
└── src/
    └── main/
        └── java/
            └── net/
                └── kobore/
                    └── matsim/
                        └── Osm2NetworkCli.java

補足（Windows から見たパス）

\\wsl$\Ubuntu\home\ebata\matsim-example-project\hirohakama\

4. 各ファイルの役割

4.1 hirohakama.osm

• OpenStreetMap からダウンロードした生の地図データ

• XML 形式

• 今後、エリアを変えればこのファイルだけ差し替える

4.2 Osm2NetworkCli.java

パス：

src/main/java/net/kobore/matsim/Osm2NetworkCli.java

役割：

• MATSim の OsmNetworkReader をラップした CLI（コマンドラインツール）

• 以下を担当：

  • OSM 読み込み

  • 利用 highway の限定

  • モード指定（car 等）

  • CRS 変換（EPSG:4326 → EPSG:6685）

  • network.xml.gz の出力

このファイルは：

• 今後 network の作り方を変えたくなった時に編集する

• 普段は直接触らない

• しかし 残しておく必要がある（再ビルド用）

4.3 pom.xml

役割：

• Maven のビルド定義

• 以下を明示的に設定している：

  • Java 17

  • MATSim 15.0

  • GeoTools EPSG 辞書（gt-epsg-hsql）

  • OSGeo リポジトリ

  • Shade Plugin（fat jar 作成）

  • 署名ファイル除外（Invalid signature file digest 対策）

  • Main class 指定

この pom.xml によって「java -jar で動く単一 JAR」が作られる

4.4 target/matsim-osm2network-1.0.0.jar

役割：

• 実行ファイル

• network.xml.gz を作るだけなら これだけあれば良い

• Java ソースを触らない限り、再ビルド不要

5. ビルド手順（必要な場合のみ）

Java ソースを変更した場合のみ実行。

cd /home/ebata/matsim-example-project/hirohakama
mvn -q -DskipTests clean package

成功すると：

target/matsim-osm2network-1.0.0.jar

が生成される。

6. network.xml.gz の生成手順（通常作業）

cd /home/ebata/matsim-example-project/hirohakama

java -jar target/matsim-osm2network-1.0.0.jar \
  --osm hirohakama.osm \
  --out output_network.xml.gz \
  --toCRS EPSG:6685 \
  --modes car

実行ログ例

[INFO] OSM      : hirohakama.osm
[INFO] OUT      : output_network.xml.gz
[INFO] toCRS    : EPSG:6685
[INFO] modes    : [car]
[INFO] highways : [motorway, motorway_link, trunk, ...]

成功すると、同ディレクトリに

output_network.xml.gz

が生成される。

7. 深いディレクトリ構造についての補足メモ

src/main/java/net/kobore/matsim/

という深さは、

• Maven の規約

• Java の package とディレクトリの 1 対 1 対応

• クラス名衝突防止（世界規模）

という Java の設計思想そのもの。

個人研究・小規模用途としては冗長だが、

• MATSim

• GeoTools

• Java エコシステム

と共存する以上、受け入れるのが最短ルート。

8. 今後の使い方方針（整理）

• OSM を変える
  → hirohakama.osm を差し替える

• network 条件を変える
  → Osm2NetworkCli.java を編集 → mvn package

• 普段の作業
  → jar を実行するだけ

9. まとめ（判断の記録）

• Python 版は「自分で制御できる」利点がある

• しかし MATSim network の正当性・再現性・説明責任を考え、

  • network 生成は MATSim API に委ねた

• この Java プログラムは
  「network.xml を作るためだけの専用工具」

• 一度作ってしまえば、運用は極めて単純