Create new types of collections

index.html

@@ -17,9 +17,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,15 @@
+export function dynamicLoad(object, data, ignore = null) {
+  let filteredData = {};
+
+  if (ignore !== null) {
+    for (const key in data) {
+      if (!ignore.has(key)) filteredData[key] = data[key];
+    }
+  } else {
+    filteredData = data;
+  }
+
+  for (const [key, value] of Object.entries(filteredData)) {
+    object[key] = value;
+  }
+}

js/types/load.js

@@ -0,0 +1,46 @@
+import { types } from "./reconstruction.js";
+import { compatible } from "./version.js";
+
+export function buildLoader(config, version) {
+  const newLoader = {};
+
+  if (typeof config === "string") config = [config];
+
+  for (const particle of config) {
+    if (types.hasOwnProperty(particle)) {
+      const isCompatible = compatible(types[particle], version);
+
+      if (isCompatible) {
+        newLoader[particle] = types[particle].load;
+      } else {
+        newLoader[particle] = () => {
+          return [];
+        };
+      }
+    }
+  }
+
+  return newLoader;
+}
+
+export function loadParticles(jsonData, event, loadersConfig) {
+  const eventData = jsonData["Event " + event];
+  const version = eventData.edm4hepVersion;
+
+  const loader = buildLoader(loadersConfig, version);
+
+  const particles = {};
+  Object.keys(loader).forEach((key) => (particles[key] = []));
+
+  for (const [type, loadFunction] of Object.entries(loader)) {
+    const particlesType = Object.values(eventData).filter(
+      (element) => element.collType === `edm4hep::${type}Collection`
+    );
+
+    particlesType.forEach(({ collection }) => {
+      const [particles, links] = loadFunction(collection);
+    });
+  }
+
+  return particles;
+}

js/types/reconstruction.js

@@ -0,0 +1,268 @@
+import { dynamicLoad } from "./dynamic.js";
+
+export class Cluster {
+  static MIN_VERSION = "0.7.0"; // may vary per type of particle
+  static MAX_VERSION = "1.0.0";
+
+  constructor() {
+    // Physics properties
+    this.type = 0;
+    this.energy = 0; // GeV
+    this.energyError = 0; // GeV
+    this.position = {}; // mm
+    this.positionError = {};
+    this.iTheta = 0;
+    this.phi = 0;
+    this.directionError = {}; // mm^2
+    this.shapeParameters = [];
+    this.subdetectorEnergies = [];
+    this.clusters = [];
+    this.hits = [];
+  }
+
+  static load(collection) {
+    const particles = [];
+    const links = createLinksManager(["clusters", "hits"]);
+
+    for (const [index, particle] of collection.entries()) {
+      const cluster = new Cluster();
+      cluster.index = index;
+
+      extractOneToManyLinks(links, ["clusters", "hits"], cluster, particle);
+
+      dynamicLoad(cluster, particle);
+
+      particles.push(cluster);
+    }
+
+    return [particles, links];
+  }
+}
+
+export class ParticleID {
+  static MIN_VERSION = "0.7.0";
+  static MAX_VERSION = "1.0.0";
+
+  constructor() {
+    // Physics properties
+    this.type = 0;
+    this.PDG = 0;
+    this.algorithmType = 0;
+    this.likelihood = 0;
+    this.parameters = [];
+    this.particle = null;
+  }
+
+  static load(collection) {
+    const particles = [];
+    const links = createLinksManager(["particle"]);
+
+    for (const [index, particle] of collection.entries()) {
+      const particleID = new ParticleID();
+      particleID.index = index;
+
+      extractOneToOneLink(links, "particle", particleID, particle);
+
+      dynamicLoad(particleID, particle);
+
+      particles.push(particleID);
+    }
+
+    return [particles, links];
+  }
+}
+
+export class ReconstructedParticle {
+  static MIN_VERSION = "0.7.0";
+  static MAX_VERSION = "1.0.0";
+
+  constructor() {
+    // Physics properties
+    this.PDG = 0;
+    this.energy = 0; // GeV
+    this.momentum = {}; // GeV
+    this.referencePoint = {}; // mm
+    this.charge = 0;
+    this.mass = 0; // GeV
+    this.goodnessOfPID = 0;
+    this.covMatrix = {};
+    this.startVertex = null;
+    this.clusters = [];
+    this.tracks = [];
+    this.particles = [];
+  }
+
+  static load(collection) {
+    const particles = [];
+    const links = createLinksManager([
+      "tracks",
+      "clusters",
+      "particles",
+      "startVertex",
+    ]);
+
+    for (const [index, particle] of collection.entries()) {
+      const reconstructedParticle = new ReconstructedParticle();
+      reconstructedParticle.index = index;
+
+      extractOneToManyLinks(
+        links,
+        ["tracks", "clusters", "particles"],
+        reconstructedParticle,
+        particle
+      );
+      extractOneToOneLink(
+        links,
+        "startVertex",
+        reconstructedParticle,
+        particle
+      );
+
+      dynamicLoad(
+        reconstructedParticle,
+        particle,
+        new Set(["tracks", "clusters", "particles", "startVertex"])
+      );
+
+      particles.push(reconstructedParticle);
+    }
+
+    return [particles, links];
+  }
+}
+
+export class Vertex {
+  static MIN_VERSION = "0.7.0";
+  static MAX_VERSION = "1.0.0";
+
+  constructor() {
+    // Physics properties
+    this.primary = 0;
+    this.chi2 = 0;
+    this.probability = 0;
+    this.position = {}; // mm
+    this.covMatrix = {};
+    this.algorithmType = 0;
+    this.parameters = 0;
+    this.associatedParticle = null;
+  }
+
+  static load(collection) {
+    const particles = [];
+    const links = createLinksManager(["associatedParticle"]);
+
+    for (const [index, particle] of collection.entries()) {
+      const vertex = new Vertex();
+      vertex.index = index;
+
+      extractOneToOneLink(links, "associatedParticle", vertex, particle);
+
+      dynamicLoad(vertex, particle, new Set(["associatedParticle"]));
+
+      particles.push(vertex);
+    }
+
+    return [particles, links];
+  }
+}
+
+export class Track {
+  static MIN_VERSION = "0.7.0";
+  static MAX_VERSION = "1.0.0";
+
+  constructor() {
+    // Physics properties
+    this.type = 0;
+    this.chi2 = 0;
+    this.ndf = 0;
+    this.dEdx = 0;
+    this.dEdxError = 0;
+    this.radiusOfInnermostHit = 0;
+    this.subdetectorHitNumbers = [];
+    this.trackStates = [];
+    this.dxQuantities = [];
+    this.trackerHits = [];
+    this.tracks = [];
+  }
+
+  static load(collection) {
+    const particles = [];
+    const links = createLinksManager(["trackerHits", "tracks"]);
+
+    for (const [index, particle] of collection.entries()) {
+      const track = new Track();
+      track.index = index;
+
+      extractOneToManyLinks(links, ["trackerHits", "tracks"], track, particle);
+
+      dynamicLoad(track, particle);
+
+      particles.push(track);
+    }
+
+    return [particles, links];
+  }
+}
+
+export class GenericLink {
+  // we may create a specific class for each type if needed
+  constructor(id, from, to) {
+    this.id = id;
+    this.from = from;
+    this.to = to;
+  }
+}
+
+export function createLinksManager(types) {
+  const links = {};
+  types.forEach((type) => (links[type] = []));
+  return links;
+}
+
+export function createGenericLink(id, from, { collectionID, index }) {
+  const genericLink = new GenericLink(id, from, index);
+  genericLink.collectionID = collectionID;
+  return genericLink;
+}
+
+export function extractOneToManyLinks(
+  linksManager,
+  keys,
+  newParticle,
+  particleData
+) {
+  for (const key of keys) {
+    particleData[key].map((val) => {
+      const link = createGenericLink(
+        linksManager[key].length,
+        newParticle.index,
+        val
+      );
+      linksManager[key].push(link);
+      newParticle[key].push(link.id);
+    });
+  }
+}
+
+export function extractOneToOneLink(
+  linksManager,
+  key,
+  newParticle,
+  particleData
+) {
+  const link = createGenericLink(
+    linksManager[key].length,
+    newParticle.index,
+    particleData[key]
+  );
+  linksManager[key].push(link);
+  newParticle[key] = link.id;
+}
+
+export const types = {
+  "Cluster": Cluster,
+  "ParticleID": ParticleID,
+  "ReconstructedParticle": ReconstructedParticle,
+  "Vertex": Vertex,
+  "Track": Track,
+};

js/types/version.js

@@ -0,0 +1,43 @@
+export class Version {
+  constructor(string) {
+    const [major, minor, patch] = string.split(".");
+    this.major = parseInt(major);
+    this.minor = parseInt(minor);
+    this.patch = parseInt(patch);
+  }
+
+  toString() {
+    return `${this.major}.${this.minor}.${this.patch}`;
+  }
+
+  greaterOrEqualThan(version) {
+    return (
+      this.major > version.major ||
+      (this.major === version.major &&
+        (this.minor > version.minor ||
+          (this.minor === version.minor && this.patch >= version.patch)))
+    );
+  }
+
+  lessOrEqualThan(version) {
+    return (
+      this.major < version.major ||
+      (this.major === version.major &&
+        (this.minor < version.minor ||
+          (this.minor === version.minor && this.patch <= version.patch)))
+    );
+  }
+
+  isBetween(version1, version2) {
+    return this.greaterOrEqualThan(version1) && this.lessOrEqualThan(version2);
+  }
+}
+
+export function compatible(type, version) {
+  const minV = new Version(type.MIN_VERSION);
+  const maxV = new Version(type.MAX_VERSION);
+
+  const v = new Version(version);
+
+  return v.isBetween(minV, maxV);
+}