Load particles according to edm4hep

js/tools.js

@@ -124,7 +124,7 @@ export function loadMCParticles(jsonData, eventNum, particlesHandler) {
   }
 }
 
-function getName(pdg) {
+export function getName(pdg) {
   const particle = mappings[pdg];
 
   if (particle !== undefined) {

js/types/dynamic.js

@@ -0,0 +1,55 @@
+import { Link, colors } from "./links.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 = [],
+  oneToOne,
+  objects
+) {
+  object.oneToOneRelations = {};
+  for (const relation of relationsToLoad) {
+    const name = relation.name;
+    const relationData = data[name];
+    if (relationData === undefined) continue;
+
+    const toObject = objects[relationData.index];
+    const link = new Link(object, toObject);
+    link.color = colors[name];
+
+    oneToOne[name].push(link);
+    object.oneToOneRelations[name] = link;
+  }
+}
+
+export function loadOneToManyRelations(
+  object,
+  data,
+  relationsToLoad = [],
+  oneToMany,
+  objects
+) {
+  object.oneToManyRelations = {};
+  for (const relation of relationsToLoad) {
+    const name = relation.name;
+    const relationData = data[name];
+
+    if (relationData === undefined) continue;
+    object.oneToManyRelations[name] = [];
+
+    for (const relationElement of relationData) {
+      const toObject = objects[relationElement.index];
+      const link = new Link(object, toObject);
+      link.color = colors[name];
+      oneToMany[name].push(link);
+      object.oneToManyRelations[name].push(link);
+    }
+  }
+}

js/types/edmobject.js

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

js/types/links.js

@@ -0,0 +1,143 @@
+export const colors = {
+  "daughters": "#00AA00",
+  "parents": "#AA0000",
+  // more if needed
+};
+
+const hexCharacters = [
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  "A",
+  "B",
+  "C",
+  "D",
+  "E",
+  "F",
+];
+
+function getCharacter(index) {
+  return hexCharacters[index];
+}
+
+export function generateRandomColor() {
+  let hexColorRep = "#";
+
+  for (let index = 0; index < 6; index++) {
+    const randomPosition = Math.floor(Math.random() * hexCharacters.length);
+    hexColorRep += getCharacter(randomPosition);
+  }
+
+  return hexColorRep;
+}
+
+export class Link {
+  // we may create a specific class for each type if needed
+  constructor(from, to) {
+    this.from = from;
+    this.to = to;
+    this.color = "#A00";
+    this.xShift = 0;
+  }
+
+  draw(ctx, infoBoxes) {
+    const boxFrom = infoBoxes[this.from];
+    const boxTo = infoBoxes[this.to];
+
+    const fromX = boxFrom.x + boxFrom.width / 2;
+    const fromY = boxFrom.y + boxFrom.height;
+    const toX = boxTo.x + boxTo.width / 2;
+    const toY = boxTo.y;
+
+    if (toY > fromY) {
+      var cpFromY = (toY - fromY) / 2 + fromY;
+      var cpToY = cpFromY;
+    } else {
+      cpFromY = (fromY - toY) / 2 + fromY;
+      cpToY = toY - (fromY - toY) / 2;
+    }
+
+    if (toX > fromX) {
+      var cpFromX = (toX - fromX) / 4 + fromX;
+      var cpToX = (3 * (toX - fromX)) / 4 + fromX;
+    } else {
+      cpFromX = (3 * (fromX - toX)) / 4 + toX;
+      cpToX = (fromX - toX) / 4 + toX;
+    }
+
+    /*
+    drawCross(ctx, fromX, fromY, "blue");
+    drawCross(ctx, toX, toY, "green");
+    drawCross(ctx, cpFromX, cpFromY, "yellow");
+    drawLine(ctx, fromX, fromY, cpFromX, cpFromY, "yellow")
+    drawCross(ctx, cpToX, cpToY, "orange");
+    drawLine(ctx, toX, toY, cpToX, cpToY, "orange")
+    */
+
+    ctx.save();
+    ctx.strokeStyle = this.color;
+    ctx.lineWidth = 2;
+    ctx.beginPath();
+    ctx.moveTo(fromX + this.xShift, fromY);
+    ctx.bezierCurveTo(
+      cpFromX + this.xShift,
+      cpFromY,
+      cpToX + this.xShift,
+      cpToY,
+      toX + this.xShift,
+      toY
+    );
+    ctx.stroke();
+    ctx.restore();
+
+    /*
+    ctx.save();
+    ctx.font = "14px sans-serif";
+    ctx.fillStyle = this.color;
+    const idText = "ID: " + this.id;
+    ctx.fillText(idText,
+                 cpToX, cpToY);
+    ctx.restore();
+    */
+  }
+
+  isVisible(x, y, width, height, infoBoxes) {
+    const boxFrom = infoBoxes[this.from];
+    const boxTo = infoBoxes[this.to];
+
+    const fromX = boxFrom.x + boxFrom.width / 2;
+    const fromY = boxFrom.y + boxFrom.height;
+    const toX = boxTo.x + boxTo.width / 2;
+    const toY = boxTo.y;
+
+    const boxX = Math.min(fromX, toX);
+    const boxWidth = Math.abs(fromX - toX);
+    const boxY = Math.min(fromY, toY);
+    const boxHeight = Math.abs(fromY - toY);
+
+    /*
+    console.log("boxX: ", this.boxX);
+    console.log("boxY: ", this.boxY);
+    console.log("boxWidth: ", this.boxWidth);
+    console.log("boxHeight: ", this.boxHeight);
+    */
+
+    return (
+      x + width > boxX &&
+      x < boxX + boxWidth &&
+      y + height > boxY &&
+      y < boxY + boxHeight
+    );
+  }
+}
+
+export function createLink(id, from, { collectionID, index }) {
+  return new Link(id, from, index, collectionID);
+}

js/types/load.js

@@ -0,0 +1,99 @@
+import { objectTypes } from "./objects.js";
+import { datatypes } from "../../output/datatypes.js";
+import {
+  loadMembers,
+  loadOneToOneRelations,
+  loadOneToManyRelations,
+} from "./dynamic.js";
+import { generateRandomColor, colors } from "./links.js";
+import json from "../../input/p8_ee_ZH_ecm240_edm4hep.edm4hep.json" assert { type: "json" };
+
+export function loadObjectType(collection, datatype, type) {
+  const objects = [];
+  let oneToOne = {};
+  if (datatype.oneToOneRelations)
+    datatype.oneToOneRelations.forEach((relation) => {
+      oneToOne[relation.name] = [];
+      if (colors[relation.name] === undefined) {
+        colors[relation.name] = generateRandomColor();
+      }
+    });
+
+  let oneToMany = {};
+  if (datatype.oneToManyRelations)
+    datatype.oneToManyRelations.forEach((relation) => {
+      oneToMany[relation.name] = [];
+      if (colors[relation.name] === undefined) {
+        colors[relation.name] = generateRandomColor();
+      }
+    });
+
+  for (const [index, particle] of collection.entries()) {
+    const newObject = new type(index);
+
+    loadMembers(newObject, particle, datatype.members);
+
+    loadOneToOneRelations(
+      newObject,
+      particle,
+      datatype.oneToOneRelations,
+      oneToOne,
+      objects
+    );
+
+    loadOneToManyRelations(
+      newObject,
+      particle,
+      datatype.oneToManyRelations,
+      oneToMany,
+      objects
+    );
+
+    objects.push(newObject);
+  }
+
+  return [objects, oneToOne, oneToMany];
+}
+
+export function loadObjects(jsonData, event, objectsToLoad) {
+  const eventData = jsonData["Event " + event];
+
+  const objects = {};
+
+  for (const type of objectsToLoad) {
+    let collectionType = Object.values(eventData).filter(
+      (element) => element.collType === `${type}Collection`
+    );
+
+    collectionType = collectionType.map((coll) => coll.collection);
+    collectionType = collectionType.flat();
+
+    const [loadedCollection, oneToOne, oneToMany] = loadObjectType(
+      collectionType,
+      datatypes[type],
+      objectTypes[type]
+    );
+
+    objects[type] = {
+      collection: loadedCollection,
+      oneToMany: oneToMany,
+      oneToOne: oneToOne,
+    };
+  }
+
+  return objects;
+}
+
+const objectsToLoad = [
+  // subset of datatypes
+  // should be changed dynamically by the user
+  // "edm4hep::Cluster",
+  // "edm4hep::ReconstructedParticle",
+  // "edm4hep::Vertex",
+  // "edm4hep::Track",
+  // "edm4hep::ParticleID",
+  "edm4hep::MCParticle",
+];
+
+const res = loadObjects(json, 0, objectsToLoad);
+console.log(res);