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 "./objects.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/edmobject.js

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

js/types/load.js

@@ -0,0 +1,57 @@
+import { objectTypes } from "./objects.js";
+import { datatypes } from "../../output/datatypes.js";
+import {
+  loadMembers,
+  loadOneToOneRelations,
+  loadOneToManyRelations,
+} from "./dynamic.js";
+
+export function loadObjectType(collection, datatype, type) {
+  const objects = [];
+
+  for (const [index, particle] of collection.entries()) {
+    const newObject = new type();
+    newObject.id = index;
+
+    loadMembers(newObject, particle, datatype.members);
+
+    if (datatype.oneToOneRelations)
+      loadOneToOneRelations(newObject, particle, datatype.oneToOneRelations);
+
+    if (datatype.oneToManyRelations)
+      loadOneToManyRelations(newObject, particle, datatype.oneToManyRelations);
+
+    objects.push(newObject);
+  }
+
+  return objects;
+}
+
+export function loadObjects(jsonData, event, objectsToLoad) {
+  const eventData = jsonData["Event " + event];
+
+  const objects = {};
+
+  for (const type of objectsToLoad) {
+    const objectsType = Object.values(eventData).filter(
+      (element) => element.collType === `${type}Collection`
+    );
+
+    objectsType.forEach(({ collection }) => {
+      loadObjectType(collection, datatypes[type], objectTypes[type]);
+    });
+  }
+
+  return objects;
+}
+
+const objectsToLoad = [
+  // subset of datatypes
+  // should be changes dynamically by the user
+  "edm4hep::Cluster",
+  "edm4hep::ReconstructedParticle",
+  "edm4hep::Vertex",
+  "edm4hep::Track",
+  "edm4hep::ParticleID",
+  "edm4hep::MCParticle",
+];

js/types/objects.js

@@ -0,0 +1,60 @@
+import { EDMObject } from "./edmobject.js";
+
+export class Cluster extends EDMObject {
+  constructor() {
+    super();
+  }
+}
+
+export class ParticleID extends EDMObject {
+  constructor() {
+    super();
+  }
+}
+
+export class ReconstructedParticle extends EDMObject {
+  constructor() {
+    super();
+  }
+}
+
+export class Vertex extends EDMObject {
+  constructor() {
+    super();
+  }
+}
+
+export class Track extends EDMObject {
+  constructor() {
+    super();
+  }
+}
+
+export class MCParticle extends EDMObject {
+  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 objectTypes = {
+  "edm4hep::Cluster": Cluster,
+  "edm4hep::ParticleID": ParticleID,
+  "edm4hep::ReconstructedParticle": ReconstructedParticle,
+  "edm4hep::Vertex": Vertex,
+  "edm4hep::Track": Track,
+  "edm4hep::MCParticle": MCParticle,
+};

js/types/units.js

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

model/.gitignore

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

model/MODEL.md

@@ -0,0 +1,34 @@
+# Keeping dmx up to date
+
+To keep dmx up to date with the event data model [edm4hep](https://github.com/key4hep/EDM4hep), we need a way to get the latest information for each datatype and component. Also, we need to take into account that dmx is deployed on github pages as a static website, so we need a way to update this info without having a server running.
+
+## How to get the latest information?
+
+In the root directory, there are two commands in `package-json` that can be used to get the latest information from the edm4hep repository. The first command
+
+```bash
+npm run download
+```
+
+will download the latest information from the edm4hep, by using the file called `edm4hep.yaml` under `model` directory, containg up to date information about `edm4hep`. The second command
+
+```bash
+npm run build
+```
+
+will generate a file called `datatypes.js` under `output` directory, where all the information is parsed and stored in a format that can be used by the dmx application.
+
+## All at once
+
+You can also run
+
+```bash
+npm run update
+```
+
+to run both processes at once and inmediatly update the dmx application.
+
+## Further improvements
+
+-   We could trigger the update process automatically when a new release of edm4hep is published, but for now, we will keep it simple and run the update process manually.
+-   To maitain backward compatibility, we could add a versioning system so we can later load different versions of the edm4hep data model into dmx, however we currrently load the latest version.

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,98 @@
+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(name, unit = null) {
+    this.name = name;
+    if (unit) this.unit = unit;
+  }
+}
+
+class Relation {
+  constructor(name) {
+    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 [_, name, unit] = parseString(member);
+    if (unit) unit = unit.replace("[", "").replace("]", "");
+    newMembers.push(new DataTypeMember(name, unit));
+  }
+
+  return newMembers;
+};
+
+const parseRelation = (relations) => {
+  return relations.map((relation) => {
+    const [_, name] = parseString(relation);
+
+    return new Relation(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);