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

トランプ関税に引き続き、米国によるベネズエラ大統領の身柄拘束の件で、私は、かなりガックリきています。
Following the Trump tariffs, I am feeling quite disheartened by the case of the Venezuelan president being taken into custody by the United States.

無論、これについても正当理由はいくらでも挙げられます。
Of course, there are several justifications for this.

麻薬対策、人権侵害、政権犯罪、地域の安全保障――私自身、それらが全くの虚構だとは思っていません。
Drug control, human rights violations, regime crimes, and regional security — I myself do not think these claims are complete fabrications.

ただし、この件が、事前に国連安保理の決議を得た形で実施されたとは報じられていません。
However, it has not been reported that this action was carried out after obtaining a prior resolution from the UN Security Council.

そういう意味では、これまで繰り返されてきた米国の単独行動の延長線上にある出来事に見えます。
In that sense, it appears to fall within the pattern of unilateral actions repeatedly taken by the United States.

-----

思い出されるのは、2003年のイラク戦争です。
What comes to mind is the Iraq War of 2003.

当時、イラクには大量破壊兵器が存在するとされ、それを根拠に軍事行動が開始されましたが、結果として核兵器を含む大量破壊兵器の決定的証拠は見つかりませんでした。
At the time, Iraq was said to possess weapons of mass destruction, and military action was initiated on that basis. Yet, ultimately, no decisive evidence of such weapons, including nuclear arms, was found.

日本国政府が、そのイラク戦争に対して資金面を中心とする形で協力したという事実も、忘れてはならないと思います。
I also believe we must not forget the fact that the Japanese government cooperated in that Iraq War, primarily through financial support.

-----

ベネズエラ大統領の身柄拘束については、個人的な心情としては、正直なところ支持できる部分もあります。
Regarding the detention of the Venezuelan president, speaking purely from a personal emotional standpoint, there are honestly aspects I can support.

また、大国のエゴであれ何であれ、各国（主に大国）が介入するという選択肢が現実に取られていれば、カンボジアやルワンダといった大量虐殺を、止められた可能性があったのではないか、とも思うからです。
This is because I also think that, regardless of whether the ego of great powers drove it, if the option of intervention by countries (mainly major powers) had actually been taken, there might have been a chance to stop mass genocides such as those in Cambodia and Rwanda.

「主権」や「内政不干渉」を盾に、国際社会が事実上手をこまねいていた結果として、ああした惨事が起きた、という側面があることも否定できません。
It cannot be denied that such tragedies occurred in part because the international community, shielding itself behind “sovereignty” and “non-interference in internal affairs,” effectively stood by and did nothing.

-----

私が、これからの子どもたちに残す言葉があるとすれば、
If there is one message I would leave for the children of the future,

―― 国際法の勉強や研究だけは、やめておけ
— I would say: stop studying or researching international law alone.

と言いたくなります。
That is what I feel compelled to tell them.

非常に虚しい気分になるからです。
Because it leads to a highly hollow feeling.

国際法そのものを否定したいわけではありません。
I do not wish to deny international law itself.

ただ、国際法"だけ"を信じ切る設計は、あまりにも危うい。
However, a framework that places absolute faith in international law *alone* is far too precarious.

国際法を勉強する時間があるなら、軍事力の定量化や、戦争・紛争をどうすれば短時間かつ局地的に、最小被害で終わらせられるのか――そうした運用やシミュレーションの研究に時間を使った方が、この果てしない無力感を感じずに済むのではないかと思うのです。
If there is time to study international law, I think it would be better spent on research into quantifying military power, and on operations and simulations that examine how wars or conflicts can be concluded quickly, locally, and with minimal damage — thereby avoiding this endless sense of helplessness.

勉強してきたことが、現実の前でまったく役に立たず、
When what one has studied turns out to be utterly useless in the face of reality,

―― なんだ、バカみたいだな
— making one think, “What was the point of all this?”

と思うような学びは、できればさせたくありません。
I would prefer not to make anyone undergo such an education.

まあ、唯一の明るい面があるとすれば、国際法に比べれば、数学や英語の勉強は、実に有用だという事実を、身をもって実感できることでしょう(個人的には、地図を睨み続けて、政治や文化を考える「地政学」がお勧めですが)。
Well, if there is one bright side, it is that compared to international law, one can truly feel through experience how helpful the study of mathematics and English is (personally, I would also recommend geopolitics — staring at maps and thinking about politics and culture).

少なくとも、それらは、世界を動かす側の言語と道具ではあると、私は思うのです。
At the very least, I believe they are languages and tools used by those who actually move the world.

正直言って、『何のために、あんなに苦労して国際条約の条文の暗記をしてきたのか』と腹が立ちます。私の怒りはどこに持っていけば良いでしょうか？ ーー とChatGPTに愚痴ってみた件

『仕事を続けている人は、認知症になりにくい』――
“People who continue working are less likely to develop dementia.”

という風に私には見えていたのですが、どうやらこれは幻想のようです。
That is how it appeared to me, but it seems to be an illusion.

これは因果関係が逆で、「認知症になっていない人が、仕事を続けられている」という状態が、そのような幻想を見せているようです。
The causality appears to be reversed: it is not that working prevents dementia, but rather that people who have not developed dementia can continue working, which creates this illusion.

仕事を続けることは、認知症の「発病リスクを下げる可能性」はありますが、「確実に防ぐ」ことはできないそうです。
Continuing to work may reduce the risk of developing dementia, but it cannot prevent it with certainty.

ただし、科学的には「仕事を続けることには、一定の抑制効果がある」とは考えられているようです。
However, scientifically, it is believed that continuing to work does have a specific suppressive effect.

―― と、ChatGPTに教えてもらったのですが、
This is what ChatGPT told me, but

『結局どっちなんだ？』と聞きたくなるような答えです。で、『はっきりしろ』と言ってみました。
It is the kind of answer that makes you want to ask, “So which is it, in the end?” So I told them, “Be clear.”

---

### ChatGPTの回答ここから

### ChatGPT’s response begins here

結論からはっきり言います。
I will state the conclusion clearly from the outset.

「仕事を続けると認知症を防げるのか？」という問いに対する科学的な答えは、『防げないが、発症を遅らせる・確率を下げる方向には働く』です。
The scientific answer to the question “Does continuing to work prevent dementia?” is: “It does not prevent it, but it does work in the direction of delaying onset and reducing probability.”

これ以上でも以下でもありません。
Nothing more, nothing less.

なぜ「どっちつかず」に聞こえるのかは、問いが二つのレベルを混同しているからです。
The reason this sounds ambiguous is that the question conflates two different levels.

① 因果関係は逆か？

1. Is the causal relationship reversed?

→ 部分的にYES
→ Partially, yes.

認知症になっていない人が、結果として仕事を続けられている。
People who have not developed dementia can continue working.

これは事実です。特に「高齢までフルタイムで働いている人」は、もともと認知機能・健康・社会的資源が高い人が多い。
This is a fact. Especially among those who work full-time into old age, many already have higher cognitive function, better health, and greater social resources.

このため、
For this reason,

「働いている → 認知症にならない」
“working → not developing dementia.”

に見える現象の一部は、
Some of what appears to be this relationship is actually

「認知症にならない人 → 働ける」
“People who do not develop dementia → can work.”

という『選別効果(サバイバー・バイアス)』です(江端注釈："幻想"という意味でしょう)。
This is a “selection effect (survivor bias)” (Ebata’s note: essentially what is meant by “illusion”).

ここを無視すると、「幻想」になります。
Ignoring this point leads directly to an illusion.

② では、仕事は“無意味”なのか？
2. Then, is work “meaningless”?

→ NO
→ No.

縦断研究・介入研究を総合すると、
When longitudinal and intervention studies are considered together,

・認知的負荷
・cognitive load
・社会的交流
・social interaction
・生活リズム
・daily rhythm
・役割意識・目的意識
・a sense of role and purpose

を伴う活動は、『認知予備能(cognitive reserve)』を高め、病理が進んでも症状の表出を遅らせることが示唆されています。
activities involving these factors are suggested to increase “cognitive reserve” and delay the manifestation of symptoms even as pathology progresses.

仕事は、これらをパッケージで満たしやすい活動です。
Work is an activity that tends to package these factors together.

だから、「発症リスクを下げる／発症時期を遅らせる可能性はある」という表現になります。
That is why it is said to “reduce risk” or “delay onset.”

③ なぜ「確実に防げない」のか？
3. Why can it not “certainly prevent” dementia?

→ 認知症は多因子疾患だからです。
→ Because dementia is a multifactorial disease.

アルツハイマー病理(アミロイドβ・タウ)、血管因子、遺伝要因(APOE ε4)、炎症・代謝・加齢。これらは、仕事をしていようが、していまいが、進行する場合があります。
Alzheimer’s pathology (amyloid-β and tau), vascular factors, genetic factors (APOE ε4), inflammation, metabolism, and aging these can progress regardless of whether one is working or not.

したがって、効果は「確率的」であり、個人差が極端に大きい。
Therefore, the effect is probabilistic, with extremely large individual differences.

予防というより「遅延」という位置づけになります。
It is better described as “delay” rather than prevention.

④ 「はっきり言え」と言われたら、こう言う
4. If asked to “state it clearly,” this is what to say

あなたの問いに対する一文での答えです。
This is the one-sentence answer to your question.

仕事を続けることは、認知症を防ぐ保証にはならないが、発症を遅らせる方向には統計的に働く。
Continuing to work does not guarantee the prevention of dementia, but it statistically helps delay the onset.

ただし、その効果は個人差が大きく、因果を単純化すると誤解が生じる。
However, the effect varies significantly among individuals, and simplifying causality leads to misunderstanding.

これが、科学的に誠実で、かつ最も「はっきりした」答えです。
This is the most scientifically honest and “clear” answer.

### ChatGPTの回答ここまで

### ChatGPT’s response ends here

---

このあともChatGPTには、
After this, I also asked ChatGPT,

「どんな種類の仕事・活動が、どの段階で、どの程度効くのか？」
“What kinds of work or activities are effective, at what stages, and to what extent?”
「仕事を辞めた後、何を代替すれば同等の効果が得られるのか？」
“And after quitting work, what can substitute to achieve similar effects?”

を聞いてみたところ、ざっくり以下の回答を貰いました。
and received roughly the following answers.

(1) 「仕事」が重要なのではなく、4つの要素が重要
(1) It is not “work” itself that is important, but four elements

(a) 認知的負荷(考える・判断する・学習する)
(a) Cognitive load (thinking, judging, learning)
(b) 社会的相互作用(他人とのやり取り)
(b) Social interaction (engaging with others)
(c) 主体性・役割(自分が必要とされる感覚)
(c) Agency and role (the feeling of being needed)
(d) 生活リズムの固定(起床・外出・予定)
(d) Fixed daily rhythm (waking, going out, scheduled activities)

(2) 上記(1)が満たされやすい仕事
(2) Jobs that tend to satisfy the above conditions

(a) 技術職、研究職、設計、教育
(a) Technical professions, research, design, education
(b) 管理職、調整役
(b) Management and coordination roles
(c) 接客・対人支援(高度なもの)
(c) Customer service and interpersonal support (at a high level)
(d) プロジェクト型業務
(d) Project-based work

(3) 上記(1)が満たされにくい仕事
(3) Jobs that tend not to satisfy the above conditions

(a) 単純反復作業のみ
(a) Purely repetitive tasks
(b) 孤立した軽作業
(b) Isolated light work

とのことでした。
That was the response.

リタイア後であっても、上記(1)の4条件が満たされるもの、例えば、語学学習、プログラミング・データ分析、楽器・作曲、大学院・公開講座などは、一定の効果が期待できるそうです。
Even after retirement, activities that satisfy the four conditions above, such as language learning, programming or data analysis, musical instruments or composition, graduate school, or public lectures, are said to offer certain benefits.

ただし、「脳トレ」は効果が弱いそうです。学習に一定のアウトプットが伴うことが重要、ということでしょう。(ぶっちゃけ、"収入"が発生するかどうか、という話に近いのかもしれません)。「脳トレ」を達成しても、対価は支払われませんからね。
However, “brain training” is said to be less effective. What matters is that learning involves some form of output, perhaps, bluntly speaking, whether income is generated or not. Completing brain training does not earn compensation, after all.

つまるところ、「参加者」では足りず、「担い手」となること。そして、失敗が許されない責任が(多少の差こそあれ)発生すること、が重要なようです。
In short, it is not enough to be a “participant”; one must be a “responsible actor.” And some degree of responsibility where failure is not easily forgiven must exist.

---

私の解釈ですが、
This is my interpretation,

(1) 『頭を使い、人と調整をし、ラクできない活動』
(1) “Activities that require thinking, coordination with others, and do not allow one to take it easy.”
(2) それが、結果として「評価や対価に晒される構造」を持っていること
(2) And that these activities are, as a result, exposed to evaluation and compensation

この2点が重要なのだと思います。
These two points are what truly matter.

多くの場合、それは「金を稼ぐ活動」という形を取りますが、本質は「逃げ場のない役割を引き受けているかどうか」なのでしょう。
In many cases, this takes the form of income-generating activities, but the essence is whether one has taken on a role with no easy escape.

さらにこれを纏めると、「引退しないこと」「現役であり続けること」そのものよりも、
Summing this up further, rather than “not retiring” or “remaining active” in itself,

―― 現役時代と同じ負荷構造を、引退後も自分で再構成できるかどうか
Can one reconstruct the same load structure after retirement?

が、発症を遅らせる方向に(確率的に)働く、と言えるのかもしれません。
May work probabilistically to delay onset.

---

つまり、私たちの年末年始休暇明けの、一年でもっとも辛い "今日" という仕事始めの日は、実は、
In other words, is the first workday after the year-end and New Year holidays the most painful day of the year? may actually be

―― 認知症の発症を遅らせるポジティブな一日(かもしれない)
a positive day that delays the onset of dementia (perhaps).

と考えれば、ほんのちょっとだけでも、憂鬱が消えるかもしれない、と言いたかったのです。
That was what I wanted to say: thinking this way might make the gloom fade just a little.

本当に、憂鬱ですよね。
It really is depressing.

皆さん、今年もよろしくお願い致します。
Wishing you all the best again this year.

『「認知症になれば、不安は解消する」という仮説について検討して下さい』とChatGPTに頼んでみた

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

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

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

ここ↓をクリックするだけです(お１人、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”

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

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

最近のNHK大河ドラマには、興味深い挑戦が見られると思います。
I think recent NHK Taiga dramas present genuinely interesting challenges.

江戸時代のメディア王の話や、宮廷文学に乗せた恋愛話など、従来にない試みで楽しませてくれました（個人的には色恋ドラマにはあまり関心がありませんが）。
Stories about a media magnate of the Edo period, or romantic tales framed in court literature, have entertained us with approaches previously uncommon (although, personally, I am not particularly interested in romantic dramas).

日本史上の著名な権力者ではなく、それを取り巻く人物（黒田官兵衛、石田三成、明智光秀等）にクローズアップしたドラマなども面白いです。
It is also interesting to see dramas that focus not on the most famous power holders in Japanese history, but on the figures surrounding them (such as Kuroda Kanbei, Ishida Mitsunari, and Akechi Mitsuhide).

今後期待されるのは、松永久秀、三好義継、篠原長房、荒木村重、津田信澄あたりが題材になると面白いのでは、と思います。
Looking ahead, I think it would be interesting if figures such as Matsunaga Hisahide, Miyoshi Yoshitsugu, Shinohara Nagafusa, Araki Murashige, or Tsuda Nobuzumi were taken up as subjects.

明治維新後では、岩瀬忠震、川路聖謨、永井尚志などはどうでしょうか。ちょっとネームバリューと視聴率の面では難しそうですが。
For the period after the Meiji Restoration, how about Iwase Tadanari, Kawaji Toshiakira, or Nagai Naoyuki? Admittedly, their name recognition and potential ratings might be an issue.

そういう意味では、今年のNHKの大河ドラマ（豊臣秀長）には、少し期待しています。
In that sense, I have modest expectations for this year’s NHK Taiga drama (Toyotomi Hidenaga).

---

多分、現実的には、絶対に実施されないとは思うのですが――
Although I think that, realistically, this would almost certainly never be implemented—

GIS（Geographic Information Systems）を使った、ドラマとの同時進行
A system that runs in parallel with the drama using GIS (Geographic Information Systems)

が見たいなぁ、と思うのです。
is something I would really like to see.

簡単に言うと、地図上に戦場を再現して、ドラマに合わせて、軍隊の移動状況や主人公の立ち位置を変えていく、というものです。
Put simply, it would recreate battlefields on a map and change troop movements and the protagonist’s position in sync with the drama.

このようなシステムを、COP（Common Operational Picture：共通作戦状況図）といいます。
Such a system is called a COP (Common Operational Picture).

戦場・部隊配置・時間経過を、主にGIS上に統合表示し、指揮官や関係者が共通の状況認識を持つための仕組みです。戦場可視化(Battlefield Visualization)システムとも呼ばれます。
It is a mechanism that integrates and displays battlefields, troop deployments, and the passage of time—primarily in GIS—so that commanders and stakeholders can share everyday situational awareness. It is also referred to as a battlefield visualization system.

もちろん、このCOPを把握できるのは、当然、視聴者だけです――ドラマの登場人物が、このシステムを視聴していたら、ドラマになりませんから。
Of course, the only ones who can grasp this COP are the viewers—if the characters in the drama themselves could see it, there would be no drama.

川中島、関ヶ原、壇ノ浦――これらのフィールドでの状況が、ドラマと連動してWebサイトで見られたとしたら――これは、いわゆる「萌え」ではなく、純粋に「燃え」ますよ。
If the situations at Kawanakajima, Sekigahara, or Dan-no-ura could be viewed on a website in sync with the drama, this would not be “moe,” but something that genuinely fires you up.

川中島、関ヶ原、壇ノ浦が、現在の日本の何県の何市にあるか、ほとんどの日本人は知らないですよね。
Most Japanese people do not know which prefecture or city in present-day Japan Kawanakajima, Sekigahara, or Dan-no-ura are actually located in, do they?

この、大河ドラマ―COPリアルタイム連動放送が実現したら、地域活性政策として、半端ではない盛り上がり方をすると思います。「アニメの『聖地巡礼』」など目ではありません（と、私は思っていますが――そうでもないかな？）。
If this kind of real-time Taiga drama–COP linked broadcast were realized, I think it would generate an extraordinary level of excitement as a regional revitalization policy. It would far surpass so-called “anime pilgrimage” tourism (at least, that’s what I think—though perhaps not?).

私が、桶狭間合戦場の出身者であることは、何度もお話してきましたが、私、「大高城」も「沓掛城」も「鳴海砦」も、その場所を知らないのです（そもそも遺跡がちゃんとあるのかも怪しい）。
I have mentioned many times that I am from the area of the Battle of Okehazama. Yet, I do not actually know the locations of Odaka Castle, Kutsukake Castle, or Narumi Fort (and I am not even sure whether proper remains still exist).

桶狭間合戦の今川軍や織田軍が、私の元実家のあった場所で、行軍または戦闘していたと分かったら――そりゃ、燃えますよ。
If it turned out that the Imagawa or Oda forces at the Battle of Okehazama had marched or fought in the very place where my former family home stood—well, that would definitely fire me up.

---

そういう意味では、GISと言わないまでも、地図（または位置情報）というのは、過去と現在をタイムリープさせる超低コストの「タイムマシン」のような存在であり、そして、歴史と地理を連携させる有効な教材であると思うのです。
In that sense, even without explicitly calling it GIS, maps (or location information) function like an ultra-low-cost “time machine” that allows us to leap between the past and the present, and they are an effective educational tool that links history and geography.

なにより、「面白い」と思う――私は。
Above all, I find it interesting—that is what I think.

ただ、これを実現するには、「歴史学者」と「地理学者」の両方を兼ね備えた人物が必要でして、戦場可視化（Battlefield Visualization）にかなりのコスト、または、歴史＆地図オタクの存在が必要になると思います。
However, to realize this, one would need someone who combines the expertise of both a historian and a geographer, and it would require considerable cost for battlefield visualization—or the presence of a serious history-and-map enthusiast.

でまあ、「現実的には、絶対に実施されないとは思うのですが」と、先んじて逃げを打っておいた訳です。
So, by saying “realistically, it would almost certainly never be implemented,” I have already hedged my bets in advance.

---

この年末年始の休みは、毎日の歩行に、少しずつジョギングを加えながら、リハビリをしていたのですが、同時に、歩きながら、北朝鮮の資料を読み漁ってもいました。
During the year-end and New Year holidays, I was doing rehabilitation by gradually adding jogging to my daily walks. At the same time, I was voraciously reading materials on North Korea while walking.

私、今日、はじめて北朝鮮の地図をまじまじと見ました。そして、私が、これまで、北朝鮮を概念、または「点」として把握していたことに気がつきました。そして、この国の中に多くの人が生きていることを、漠然と感じることができました。
Today, for the first time, I closely examined a map of North Korea. I realized that until now I had perceived North Korea merely as a concept or a “point,” and I was able, albeit vaguely, to sense that many people actually live there.

地図を見てみると、その国の政治体制や国民の気質が見えてくる気がします――地政学というものではなくて、国を陸地で接している国々を見ると、それぞれの国が、早朝ラッシュ時の山手線に乗っている乗客のように見えてきて、なかなか示唆に富んでいて、面白いものです。
When you look at a map, you begin to feel that you can see a country’s political system and the temperament of its people—not in the sense of geopolitics, but rather as if the countries sharing land borders resemble passengers riding the Yamanote Line during the early-morning rush hour, which is quite thought-provoking and engaging.

もし「弔われていない戦死者の上に建つ土地」を事故物件と呼ぶのであれば、日本中の平野部は、ほぼ全滅です。

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 を書かない／空にするのは一般的

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

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

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