lhcb-ntuple-wizard-test 2.0.0 → 2.0.1

package/dist/components/tupleToolParams/StrParamInput.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/*****************************************************************************\
+ * (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.                                       *
+ \*****************************************************************************/
+import { Form } from "react-bootstrap";
+export function sanitizeStrTupleToolParam(value) {
+    // Allow letters, numbers, _, :, and -
+    return value.replaceAll(/[^\w:-]/g, "");
+}
+export function StrParamInput({ onChange, value, defaultValue, param }) {
+    return (_jsx(_Fragment, { children: _jsx(Form.Control, { type: "text", value: value, placeholder: defaultValue?.toString(), onChange: (event) => {
+                const value = event.target.value;
+                onChange(param === "ExtraName" ? value.replaceAll(/\W/g, "") : sanitizeStrTupleToolParam(value));
+            } }) }));
+}

package/dist/config.d.ts

@@ -0,0 +1,78 @@
+export declare const config: {
+    metadata_baseurl: string;
+    metadata_files: {
+        particleProperties: string;
+        lokiVariables: string;
+        decays: string;
+        stripping: string;
+        strippingHints: string;
+        userHints: string;
+        tupleTools: string;
+        dataset: string;
+        kgdoc: string;
+        embedding: string;
+    };
+    batch_size: number;
+    particleTagGroupStyles: {
+        category: string;
+        charge: string;
+        flavour: string;
+        spin: string;
+        lifetime: string;
+    };
+    dttGraphOptions: {
+        layout: {
+            hierarchical: {
+                sortMethod: string;
+            };
+        };
+        nodes: {
+            borderWidth: number;
+            borderWidthSelected: number;
+            imagePadding: number;
+            font: {
+                strokeWidth: number;
+                background: string;
+            };
+            color: {
+                background: string;
+                highlight: {
+                    background: string;
+                };
+                hover: {
+                    background: string;
+                };
+            };
+            scaling: {
+                min: number;
+                max: number;
+            };
+            value: number;
+            shape: string;
+            shapeProperties: {
+                useBorderWithImage: boolean;
+                useImageSize: boolean;
+            };
+        };
+        edges: {
+            color: string;
+            width: number;
+            selectionWidth: number;
+            hoverWidth: number;
+        };
+        physics: {
+            enabled: boolean;
+        };
+        interaction: {
+            dragNodes: boolean;
+            multiselect: boolean;
+            selectConnectedEdges: boolean;
+            hoverConnectedEdges: boolean;
+            hover: boolean;
+            zoomView: boolean;
+        };
+        height: string;
+        autoResize: boolean;
+        width: string;
+    };
+};

package/dist/config.js

@@ -0,0 +1,72 @@
+export const config = {
+    metadata_baseurl: "https://lbwizard-metadata.web.cern.ch/3.1.0/",
+    metadata_files: {
+        particleProperties: "particle_properties",
+        lokiVariables: "loki",
+        decays: "decays",
+        stripping: "stripping",
+        strippingHints: "stripping_hints",
+        userHints: "user_hints",
+        tupleTools: "tupletools",
+        dataset: "dataset",
+        kgdoc: "kgdoc",
+        embedding: "embedding",
+    },
+    batch_size: 10,
+    particleTagGroupStyles: {
+        category: "dark",
+        charge: "primary",
+        flavour: "success",
+        spin: "danger",
+        lifetime: "secondary",
+    },
+    dttGraphOptions: {
+        layout: {
+            hierarchical: { sortMethod: "directed" },
+        },
+        nodes: {
+            borderWidth: 0,
+            borderWidthSelected: 0,
+            imagePadding: 10,
+            font: {
+                strokeWidth: 20,
+                background: "white",
+            },
+            color: {
+                background: "white",
+                highlight: { background: "white" },
+                hover: { background: "#eee" },
+            },
+            scaling: {
+                min: 32,
+                max: 32,
+            },
+            value: 1,
+            shape: "image",
+            shapeProperties: {
+                useBorderWithImage: true,
+                useImageSize: false,
+            },
+        },
+        edges: {
+            color: "black",
+            width: 1,
+            selectionWidth: 0,
+            hoverWidth: 0,
+        },
+        physics: {
+            enabled: false,
+        },
+        interaction: {
+            dragNodes: false,
+            multiselect: true,
+            selectConnectedEdges: false,
+            hoverConnectedEdges: false,
+            hover: true,
+            zoomView: false,
+        },
+        height: "500px",
+        autoResize: true,
+        width: "100%",
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/*****************************************************************************\
+* (c) Copyright 2025 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 { NtupleWizard } from "./components/NtupleWizard.js";

package/dist/index.js

@@ -0,0 +1,11 @@
+/*****************************************************************************\
+* (c) Copyright 2025 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 { NtupleWizard } from "./components/NtupleWizard.js";

package/dist/models/bkPath.d.ts

@@ -0,0 +1,11 @@
+export default class BkPath {
+    path: string;
+    isMC: boolean;
+    constructor(path: string);
+    getStrippingVersion(): string;
+    getYear(): string;
+    getPolarity(): string | null;
+    getFilename(): string;
+    getEventType(): string;
+    isValid(): boolean;
+}

package/dist/models/bkPath.js

@@ -0,0 +1,40 @@
+export default class BkPath {
+    path;
+    isMC;
+    constructor(path) {
+        this.path = path;
+        this.isMC = path.split("/")[1] === "MC";
+    }
+    getStrippingVersion() {
+        return this.path.split("/")[this.isMC ? 7 : 6].replace("Stripping", "").replace("NoPrescalingFlagged", "");
+    }
+    getYear() {
+        return this.path.split("/")[2].replace("Collision", "20");
+    }
+    getPolarity() {
+        const matchingPolarities = ["MagUp", "MagDown"].filter((polarity) => this.path.includes(polarity));
+        return matchingPolarities.length === 1 ? matchingPolarities[0] : null;
+    }
+    getFilename() {
+        return this.path.split("/")[this.isMC ? 9 : 8];
+    }
+    getEventType() {
+        return this.path.split("/")[this.isMC ? 8 : 7];
+    }
+    isValid() {
+        const bkArray = this.path.split("/");
+        if (bkArray[0] !== "") {
+            return false;
+        }
+        if (!this.path.toLowerCase().endsWith("dst")) {
+            return false;
+        }
+        if (bkArray.length === 9 && bkArray[1] === "LHCb") {
+            return true;
+        }
+        else if (bkArray.length === 10 && bkArray[1] === "MC") {
+            return true;
+        }
+        return false;
+    }
+}

package/dist/models/blobFile.d.ts

@@ -0,0 +1,12 @@
+export interface BlobFileDefaults {
+    application: string;
+    wg: string;
+    inform: string[];
+    automatically_configure: boolean;
+    output: string;
+}
+export interface BlobFile {
+    name: string;
+    defaults: BlobFileDefaults;
+    blob: Blob;
+}

package/dist/models/blobFile.js

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

package/dist/models/decayData.d.ts

@@ -0,0 +1,15 @@
+import { BranchMapItem } from "./dtt.js";
+export interface DecayDescriptors {
+    plain: string;
+    latex: string;
+    template: string;
+    mapped_list: BranchMapItem[];
+    list: string[];
+}
+export interface DecayData {
+    descriptors: DecayDescriptors;
+    lines: {
+        [key: string]: string[];
+    };
+    tags: string[];
+}

package/dist/models/decayData.js

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

package/dist/models/dropdownOption.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from "react";
+export interface DropdownOption {
+    value: string;
+    label: string | ReactNode;
+}

package/dist/models/dropdownOption.js

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

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();
+    }
+}