Load particles according to edm4hep

index.html

@@ -18,9 +18,9 @@
   <div id="input-modal" class="modal-background">
     <div class="modal-content">
 
-      <p>¡Welcome to <span id="logo">
+      <p>Welcome to <span id="logo">
           <span id="logo-d">d</span><span id="logo-m">m</span><span id="logo-x">X</span>
-        </span>!</p>
+        </span></p>
 
       <div id="input-message">
       </div>

js/types/dynamic.js

@@ -0,0 +1,35 @@
+import { createLink } from "./reconstruction.js";
+
+export function loadMembers(object, data, membersToLoad) {
+  for (const member of membersToLoad) {
+    if (data[member.name] === undefined) continue; // load up to date data
+    object.members[member.name] = data[member.name];
+  }
+}
+
+export function loadOneToOneRelations(object, data, relationsToLoad) {
+  object.oneToOneRelations = {};
+  for (const relation of relationsToLoad) {
+    const relationData = data[relation.name];
+    if (relationData === undefined) continue;
+
+    const link = createLink(object.id, object.id, relationData);
+    object.oneToOneRelations[relation.name] = link;
+  }
+}
+
+export function loadOneToManyRelations(object, data, relationsToLoad) {
+  object.oneToManyRelations = {};
+  for (const relation of relationsToLoad) {
+    const name = relation.name;
+    const relationData = data[name];
+
+    if (relationData === undefined) continue;
+    object.oneToManyRelations[name] = [];
+
+    for (const [index, relationElement] of relationData.entries()) {
+      const link = createLink(index + object.id, object.id, relationElement);
+      object.oneToManyRelations[name].push(link);
+    }
+  }
+}

js/types/load.js

@@ -0,0 +1,62 @@
+import { reconstructionTypes } from "./reconstruction.js";
+import { datatypes } from "../../output/datatypes.js";
+import {
+  loadMembers,
+  loadOneToOneRelations,
+  loadOneToManyRelations,
+} from "./dynamic.js";
+import json from "../../input/p8_ee_ZH_ecm240_edm4hep.edm4hep.json" assert { type: "json" };
+
+export function loadParticleType(collection, datatype, type) {
+  const particles = [];
+
+  for (const [index, particle] of collection.entries()) {
+    const newParticle = new type();
+    newParticle.id = index;
+
+    loadMembers(newParticle, particle, datatype.members);
+
+    if (datatype.oneToOneRelations)
+      loadOneToOneRelations(newParticle, particle, datatype.oneToOneRelations);
+
+    if (datatype.oneToManyRelations)
+      loadOneToManyRelations(
+        newParticle,
+        particle,
+        datatype.oneToManyRelations
+      );
+
+    particles.push(newParticle);
+  }
+
+  return particles;
+}
+
+export function loadParticles(jsonData, event, particlesToLoad) {
+  const eventData = jsonData["Event " + event];
+
+  const particles = {};
+
+  for (const type of particlesToLoad) {
+    const particlesType = Object.values(eventData).filter(
+      (element) => element.collType === `${type}Collection`
+    );
+
+    particlesType.forEach(({ collection }) => {
+      loadParticleType(collection, datatypes[type], reconstructionTypes[type]);
+    });
+  }
+
+  return particles;
+}
+
+const particlesToLoad = [
+  // subset of types
+  "edm4hep::Cluster",
+  "edm4hep::ReconstructedParticle",
+  "edm4hep::Vertex",
+  "edm4hep::Track",
+  "edm4hep::ParticleID",
+];
+
+loadParticles(json, 0, particlesToLoad);

js/types/particle.js

@@ -0,0 +1,8 @@
+export class Particle {
+  constructor() {
+    this.members = {};
+  }
+
+  draw() {}
+  // more methods common to all particles
+}

js/types/reconstruction.js

@@ -0,0 +1,59 @@
+import { Particle } from "./particle.js";
+
+class Reconstruction extends Particle {
+  constructor() {
+    super();
+  }
+}
+
+export class Cluster extends Reconstruction {
+  constructor() {
+    super();
+  }
+}
+
+export class ParticleID extends Reconstruction {
+  constructor() {
+    super();
+  }
+}
+
+export class ReconstructedParticle extends Reconstruction {
+  constructor() {
+    super();
+  }
+}
+
+export class Vertex extends Reconstruction {
+  constructor() {
+    super();
+  }
+}
+
+export class Track extends Reconstruction {
+  constructor() {
+    super();
+  }
+}
+
+export class GenericLink {
+  // we may create a specific class for each type if needed
+  constructor(id, from, to, collectionID) {
+    this.id = id;
+    this.from = from;
+    this.to = to;
+    this.collectionID = collectionID;
+  }
+}
+
+export function createLink(id, from, { collectionID, index }) {
+  return new GenericLink(id, from, index, collectionID);
+}
+
+export const reconstructionTypes = {
+  "edm4hep::Cluster": Cluster,
+  "edm4hep::ParticleID": ParticleID,
+  "edm4hep::ReconstructedParticle": ReconstructedParticle,
+  "edm4hep::Vertex": Vertex,
+  "edm4hep::Track": Track,
+};

js/types/units.js

@@ -0,0 +1,7 @@
+export const units = {
+  "charge": "e",
+  "mass": "GeV",
+  "time": "ns",
+  "momentum": "GeV",
+  "vertex": "mm",
+};

model/.gitignore

@@ -0,0 +1,2 @@
+*.yaml
+*.yml

model/download.js

@@ -0,0 +1,17 @@
+import https from "https";
+import fs from "fs";
+
+const URL =
+  "https://raw.githubusercontent.com/key4hep/EDM4hep/main/edm4hep.yaml";
+
+const folder = process.argv[2] ?? "model";
+
+const file = fs.createWriteStream(`${folder}/edm4hep.yaml`);
+https.get(URL, (res) => {
+  res.pipe(file);
+
+  file.on("finish", () => {
+    file.close();
+    console.log("Download completed");
+  });
+});

model/index.js

@@ -0,0 +1,100 @@
+import jsYaml from "js-yaml";
+import fs from "fs/promises";
+
+const fileRoute = process.argv[2] ?? "model/edm4hep.yaml";
+const folderOutput = process.argv[3] ?? "output";
+
+const definitionFile = await fs.readFile(fileRoute, "utf-8");
+const definitionObject = jsYaml.load(definitionFile);
+
+const components = definitionObject.components;
+const datatypes = definitionObject.datatypes;
+
+const configTypes = new Set([
+  "edm4hep::Cluster",
+  "edm4hep::ParticleID",
+  "edm4hep::MCParticle",
+  "edm4hep::Vertex",
+  "edm4hep::ReconstructedParticle",
+  "edm4hep::Track",
+]);
+
+const selectedTypes = Object.entries(datatypes).filter(([key, _]) =>
+  configTypes.has(key)
+);
+
+const componentsDefinition = {};
+const datatypesDefinition = {};
+
+class Component {}
+
+class DataTypeMember {
+  constructor(type, name, unit = null) {
+    this.type = type;
+    this.name = name;
+    if (unit) this.unit = unit;
+  }
+}
+
+class Relation {
+  constructor(type, name) {
+    this.type = type;
+    this.name = name;
+  }
+}
+
+const parseString = (string) => {
+  return string
+    .split("//")[0]
+    .trim()
+    .split(" ")
+    .filter((substring) => substring !== "");
+};
+
+const parseDatatypesMembers = (members) => {
+  const newMembers = [];
+
+  for (const member of members) {
+    let [type, name, unit] = parseString(member);
+    if (unit) unit = unit.replace("[", "").replace("]", "");
+    const newMember = new DataTypeMember(type, name, unit);
+    newMembers.push(newMember);
+  }
+
+  return newMembers;
+};
+
+const parseRelation = (relations) => {
+  return relations.map((relation) => {
+    const [type, name] = parseString(relation);
+    return new Relation(type, name);
+  });
+};
+
+selectedTypes.forEach(([name, values]) => {
+  const members = values["Members"] ?? false;
+  let parsedMembers;
+  if (members) parsedMembers = parseDatatypesMembers(members);
+  const oneToManyRelations = values["OneToManyRelations"] ?? false;
+  let parsedOneToManyRelations;
+  if (oneToManyRelations)
+    parsedOneToManyRelations = parseRelation(oneToManyRelations);
+  const oneToOneRelations = values["OneToOneRelations"] ?? false;
+  let parsedOneToOneRelations;
+  if (oneToOneRelations)
+    parsedOneToOneRelations = parseRelation(oneToOneRelations);
+
+  datatypesDefinition[name] = {
+    members: parsedMembers,
+    oneToManyRelations: parsedOneToManyRelations,
+    oneToOneRelations: parsedOneToOneRelations,
+  };
+});
+
+const output = `export const datatypes = ${JSON.stringify(
+  datatypesDefinition,
+  null,
+  2
+)}`;
+
+await fs.writeFile(`${folderOutput}/datatypes.js`, output);