lhcb-ntuple-wizard-test 1.3.3 → 2.0.1

package/dist/models/dtt.d.ts

@@ -0,0 +1,108 @@
+import { TupleTool } from "./tupleTool";
+import { StrippingLine } from "./strippingLine";
+/*****************************************************************************\
+ * (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration           *
+ *                                                                             *
+ * This software is distributed under the terms of the GNU General Public      *
+ * Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING".   *
+ *                                                                             *
+ * In applying this licence, CERN does not waive the privileges and immunities *
+ * granted to it by virtue of its status as an Intergovernmental Organization  *
+ * or submit itself to any jurisdiction.                                       *
+ \*****************************************************************************/
+export type ToolParamTypeMap = {
+    bool: boolean;
+    int: number;
+    uint: number;
+    float: number;
+    str: string;
+    text: string[];
+    "[int]": number[];
+    "[uint]": number[];
+    "[float]": number[];
+    "{str:str}": {
+        [key: string]: string;
+    };
+    "{str:[str]}": {
+        [key: string]: string[];
+    };
+};
+export interface ToolParamMetadata<K extends keyof ToolParamTypeMap> {
+    cpp_type: string;
+    default: ToolParamTypeMap[K];
+    description: string;
+    name: string;
+    type: K;
+}
+export interface ToolMetadata {
+    [key: string]: {
+        description: string;
+        documentation: string;
+        interface: ToolParamMetadata<keyof ToolParamTypeMap>[];
+        tags: string[];
+    };
+}
+export type ToolParam<K extends keyof ToolParamTypeMap> = {
+    value: ToolParamTypeMap[K];
+} & ToolParamMetadata<K>;
+export type AnyToolParam = {
+    [K in keyof ToolParamTypeMap]: ToolParam<K>;
+}[keyof ToolParamTypeMap];
+export interface ToolConfig {
+    [toolParamName: string]: AnyToolParam;
+}
+export interface BranchConfig {
+    particle: string;
+    tools: {
+        [toolString: string]: ToolConfig;
+    };
+}
+export interface GroupConfig {
+    particles: string[];
+    tools: {
+        [toolString: string]: ToolConfig;
+    };
+}
+export interface DttConfig {
+    inputs?: string[];
+    descriptorTemplate?: string;
+    tools: {
+        [toolName: string]: ToolConfig;
+    };
+    branches: {
+        [particleId: string]: BranchConfig;
+    };
+    groups: {
+        [particleGroup: string]: GroupConfig;
+    };
+    name?: string;
+}
+export interface Branch {
+    branch: string;
+    particle: string;
+}
+export type BranchMapItem = Branch | BranchMapItem[];
+export default class Dtt {
+    config: DttConfig;
+    metadata: ToolMetadata;
+    constructor(config: DttConfig, toolMetadata: ToolMetadata);
+    private static getBranchConfigs;
+    static create(descriptorTemplate: string, branchItemsList: BranchMapItem[], inputs: string[], name: string, toolMetadata: ToolMetadata): Dtt;
+    withInputsFromLines(lines: StrippingLine[]): Dtt;
+    withName(name: string): Dtt;
+    withConfig(config: DttConfig): Dtt;
+    withAddedTool(tool: TupleTool, branch?: string[]): Dtt;
+    withUpdatedToolParam<K extends keyof ToolParamTypeMap>(branch: string[], tool: TupleTool, param: string, value: ToolParamTypeMap[K]): Dtt;
+    withRemovedTool(tool: TupleTool, branch?: string[]): Dtt;
+    getName(): string;
+    pruneGroups(): void;
+    getToolsByBranch(branch?: string[]): {
+        [toolString: string]: ToolConfig;
+    };
+    private static getToolsByBranchFromConfig;
+    getParticlesByBranchId(branchIds: string[]): string[];
+    private static getDefaultToolConfig;
+    getToolConfig(branch: string[], tool: TupleTool): ToolConfig;
+    listTools(branch?: string[]): TupleTool[];
+    toolExists(tool: TupleTool, branch?: string[]): boolean;
+}

package/dist/models/dtt.js

@@ -0,0 +1,149 @@
+import { TupleTool } from "./tupleTool";
+export default class Dtt {
+    config;
+    metadata;
+    /* Class for customising the configuration of a DecayTreeTuple algorithm.
+     * The output will be parsed by a custom parser in the AnalysisHelpers data-package.
+     */
+    constructor(config, toolMetadata) {
+        this.config = config;
+        this.metadata = toolMetadata;
+    }
+    static getBranchConfigs(branchItemsList) {
+        const branches = {};
+        const walk = (item, parentId) => {
+            if (Array.isArray(item)) {
+                item.forEach((t) => walk(t, parentId));
+            }
+            else {
+                branches[item.branch] = { particle: item.particle, tools: {} };
+            }
+        };
+        branchItemsList.forEach((bmap) => walk(bmap, null));
+        return branches;
+    }
+    static create(descriptorTemplate, branchItemsList, inputs, name, toolMetadata) {
+        const defaultTools = [
+            // default tool list in DaVinci v45r7
+            // TODO: load this from a file generated on deployment
+            "TupleToolKinematic",
+            "TupleToolPid",
+            "TupleToolANNPID",
+            "TupleToolGeometry",
+            "TupleToolEventInfo",
+        ];
+        return new Dtt({
+            inputs,
+            descriptorTemplate,
+            tools: Object.fromEntries(defaultTools.map((tool) => [tool, Dtt.getDefaultToolConfig(toolMetadata, tool)])),
+            branches: Dtt.getBranchConfigs(branchItemsList),
+            groups: {},
+            name,
+        }, toolMetadata);
+    }
+    withInputsFromLines(lines) {
+        const inputs = lines.map(({ stream, line }) => {
+            const lineLocation = String(line).replace("Stripping", "");
+            return `/Event/${stream}/Phys/${lineLocation}/Particles`;
+        });
+        return new Dtt({ ...this.config, inputs }, this.metadata);
+    }
+    // Set the class+name combination
+    withName(name) {
+        const safeName = name.replace(/\W/g, "");
+        return new Dtt({ ...this.config, name: `DecayTreeTuple/${safeName}` }, this.metadata);
+    }
+    withConfig(config) {
+        return new Dtt(config, this.metadata);
+    }
+    withAddedTool(tool, branch) {
+        const nextConfig = structuredClone(this.config);
+        const tools = Dtt.getToolsByBranchFromConfig(nextConfig, branch);
+        const key = tool.toString();
+        if (tools[key])
+            return this; // already exists
+        tools[key] = Dtt.getDefaultToolConfig(this.metadata, tool.class);
+        return new Dtt(nextConfig, this.metadata);
+    }
+    withUpdatedToolParam(branch, tool, param, value) {
+        const nextConfig = structuredClone(this.config);
+        const tools = Dtt.getToolsByBranchFromConfig(nextConfig, branch);
+        tools[tool.toString()][param].value = value;
+        return new Dtt(nextConfig, this.metadata);
+    }
+    withRemovedTool(tool, branch) {
+        const nextConfig = structuredClone(this.config);
+        const tools = Dtt.getToolsByBranchFromConfig(nextConfig, branch);
+        delete tools[tool.toString()];
+        return new Dtt(nextConfig, this.metadata);
+    }
+    // Return the name of the DecayTreeTuple algorithm
+    getName() {
+        if (!this.config.name) {
+            return "";
+        }
+        return this.config.name.split("/")[1];
+    }
+    // Delete all groups with an empty tool list
+    pruneGroups() {
+        for (const [key, groupConfig] of Object.entries(this.config.groups)) {
+            if (Object.keys(groupConfig.tools).length === 0) {
+                delete this.config.groups[key];
+            }
+        }
+    }
+    // Find the appropriate object which has a "tools" list
+    getToolsByBranch(branch) {
+        this.pruneGroups();
+        return Dtt.getToolsByBranchFromConfig(this.config, branch);
+    }
+    static getToolsByBranchFromConfig(config, branch) {
+        if (!branch || branch?.length === 0) {
+            return config.tools;
+        }
+        if (branch.length === 1 && branch[0] in config.branches) {
+            return config.branches[branch[0]].tools;
+        }
+        const particleGroup = branch.join(",");
+        if (!(particleGroup in config.groups)) {
+            // Create the group if it doesn't exist
+            config.groups[particleGroup] = {
+                particles: branch.map((pid) => config.branches[pid].particle),
+                tools: {},
+            };
+        }
+        return config.groups[particleGroup].tools;
+    }
+    getParticlesByBranchId(branchIds) {
+        this.pruneGroups();
+        if (branchIds.length === 1 && branchIds[0] in this.config.branches) {
+            return [this.config.branches[branchIds[0]].particle];
+        }
+        const particleGroup = branchIds.join(",");
+        if (!(particleGroup in this.config.groups)) {
+            // Create the group if it doesn't exist
+            this.config.groups[particleGroup] = {
+                particles: branchIds.map((id) => this.config.branches[id].particle),
+                tools: {},
+            };
+        }
+        return this.config.groups[particleGroup].particles;
+    }
+    // Return a dict containing the default configuration of a TupleTool
+    static getDefaultToolConfig(toolMetadata, toolClass) {
+        const paramMetadata = toolMetadata[toolClass].interface.filter((param) => param.name !== "Preambulo");
+        return Object.fromEntries(paramMetadata.map((metadata) => [metadata.name, { value: metadata.default, ...metadata }]));
+    }
+    // Return the current config dict of a tool, so it can be modified by the user
+    getToolConfig(branch, tool) {
+        const tools = this.getToolsByBranch(branch);
+        return tools[tool.toString()];
+    }
+    // Return a list of strings corresponding to the target's tool list
+    listTools(branch) {
+        return Object.keys(this.getToolsByBranch(branch)).map((toolString) => TupleTool.fromString(toolString));
+    }
+    toolExists(tool, branch) {
+        return tool.toString() in this.getToolsByBranch(branch);
+    }
+}

package/dist/models/jobConfig.d.ts

@@ -0,0 +1,7 @@
+export interface JobConfig {
+    options: string[];
+    input: {
+        bk_query: string;
+    };
+    root_in_tes?: string;
+}

package/dist/models/jobConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/models/particle.d.ts

@@ -0,0 +1,12 @@
+export interface Particle {
+    antiparticle: string;
+    charge: number;
+    hide: boolean;
+    html: string;
+    latex: string;
+    mass: number;
+    pid: number;
+    prefix: string;
+    stable: boolean;
+    tags: string[];
+}

package/dist/models/particle.js

@@ -0,0 +1 @@
+export {};

package/dist/models/particleTag.d.ts

@@ -0,0 +1,4 @@
+export interface ParticleTag {
+    label: string;
+    group: string;
+}

package/dist/models/particleTag.js

@@ -0,0 +1 @@
+export {};

package/dist/models/rowData.d.ts

@@ -0,0 +1,15 @@
+import Dtt from "./dtt.js";
+import { DecayData } from "./decayData";
+import { StrippingLine } from "./strippingLine.js";
+export interface RowData {
+    id: number;
+    decay: DecayData;
+    dtt: Dtt | null;
+    editTree?: boolean;
+    lines: StrippingLine[];
+    paths: string[];
+    pathOptions: string[];
+}
+export type ConfiguredRow = RowData & {
+    dtt: NonNullable<RowData["dtt"]>;
+};

package/dist/models/rowData.js

@@ -0,0 +1 @@
+export {};

package/dist/models/strippingLine.d.ts

@@ -0,0 +1,5 @@
+export interface StrippingLine {
+    line: string;
+    stream: string;
+    versions: string[];
+}

package/dist/models/strippingLine.js

@@ -0,0 +1 @@
+export {};

package/dist/models/strippingLineOption.d.ts

@@ -0,0 +1,6 @@
+import { JSX } from "react";
+export interface StrippingLineOption {
+    group: string;
+    label: JSX.Element | string;
+    value: string;
+}

package/dist/models/strippingLineOption.js

@@ -0,0 +1 @@
+export {};

package/dist/models/tupleTool.d.ts

@@ -0,0 +1,8 @@
+export declare class TupleTool {
+    class: string;
+    name: string;
+    constructor(toolClass: string, name: string);
+    toString(): string;
+    static fromString(this: void, toolString: string): TupleTool;
+    equals(other: TupleTool): boolean;
+}

package/dist/models/tupleTool.js

@@ -0,0 +1,18 @@
+export class TupleTool {
+    class;
+    name;
+    constructor(toolClass, name) {
+        this.class = toolClass;
+        this.name = name;
+    }
+    toString() {
+        return this.name ? `${this.class}/${this.name}` : this.class;
+    }
+    static fromString(toolString) {
+        const [toolClass, name] = toolString.split("/");
+        return new TupleTool(toolClass, name || "");
+    }
+    equals(other) {
+        return this.toString() === other.toString();
+    }
+}

package/dist/models/tupleTreeGraphData.d.ts

@@ -0,0 +1,20 @@
+export interface TupleTreeGraphData {
+    nodes: TupleTreeNode[];
+    edges: TupleTreeEdge[];
+}
+interface TupleTreeEdge {
+    from: string;
+    id?: string;
+    to: string;
+}
+interface TupleTreeNode {
+    id: string;
+    label: string;
+    title: HTMLSpanElement;
+    shape: string;
+    image: {
+        selected: string;
+        unselected: string;
+    };
+}
+export {};

package/dist/models/tupleTreeGraphData.js

@@ -0,0 +1 @@
+export {};

package/dist/models/yamlFile.d.ts

@@ -0,0 +1,11 @@
+import Dtt from "./dtt";
+import { RowData } from "./rowData";
+import { MetadataContext } from "../providers/MetadataProvider";
+export declare class YamlFile {
+    name: string;
+    content: string;
+    constructor(name: string, content: string);
+    static fromDtt(dtt: Dtt): YamlFile;
+    private static reformatTools;
+    static createInfoYaml(rows: RowData[], metadata: MetadataContext): YamlFile;
+}

package/dist/models/yamlFile.js

@@ -0,0 +1,78 @@
+import yaml from "js-yaml";
+import { sanitizeFilename } from "../utils/utils";
+export class YamlFile {
+    name;
+    content;
+    constructor(name, content) {
+        this.name = sanitizeFilename(name);
+        this.content = content;
+    }
+    static fromDtt(dtt) {
+        const yamlContent = {
+            ...dtt.config,
+            tools: YamlFile.reformatTools(dtt.config.tools),
+            branches: Object.fromEntries(Object.entries(dtt.config.branches).map(([branchId, branchConfig]) => [
+                branchId,
+                {
+                    ...branchConfig,
+                    tools: YamlFile.reformatTools(branchConfig.tools),
+                },
+            ])),
+            groups: Object.fromEntries(Object.entries(dtt.config.groups).map(([groupId, groupConfig]) => [
+                groupId,
+                {
+                    ...groupConfig,
+                    tools: YamlFile.reformatTools(groupConfig.tools),
+                },
+            ])),
+        };
+        return new YamlFile(`${dtt.getName()}.yaml`, yaml.dump(yamlContent));
+    }
+    static reformatTools(tools) {
+        return Object.entries(tools).map(([toolName, toolConfig]) => ({
+            [toolName]: Object.fromEntries(Object.entries(toolConfig).map(([paramName, param]) => [paramName, param.value])),
+        }));
+    }
+    static createInfoYaml(rows, metadata) {
+        const uniquePathSet = new Set(rows.flatMap((row) => row.paths));
+        const uniquePaths = [...uniquePathSet].sort();
+        const pathIndex = new Map(uniquePaths.map((p, i) => [p, i]));
+        const info = {
+            defaults: {
+                application: `DaVinci/${metadata.tupleTools.applicationInfo.DaVinci}`,
+                wg: "OpenData",
+                inform: [],
+                automatically_configure: true,
+                output: "DVNtuple.root",
+            },
+        };
+        for (const row of rows) {
+            if (!row.dtt)
+                continue;
+            for (const path of row.paths) {
+                const jobID = pathIndex.get(path);
+                if (jobID === undefined)
+                    continue;
+                const key = `job${jobID}`;
+                const dttFile = row.dtt.getName();
+                if (key in info) {
+                    info[key].options.push(dttFile);
+                }
+                else {
+                    const job = {
+                        input: { bk_query: path },
+                        options: [dttFile],
+                    };
+                    if (path.includes("MDST")) {
+                        const stream = row.lines[0]?.stream;
+                        if (stream) {
+                            job.root_in_tes = `/Event/${stream}`;
+                        }
+                    }
+                    info[key] = job;
+                }
+            }
+        }
+        return new YamlFile("info.yaml", yaml.dump(info));
+    }
+}

package/dist/pages/DecaySearchPage.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    basePath: string;
+}
+export declare function DecaySearchPage({ basePath }: Props): import("react/jsx-runtime").JSX.Element;
+export {};