correctionlib 2.9.0__cp313-cp313-win_arm64.whl

correctionlib/JSONEncoder.py

@@ -0,0 +1,173 @@
+"""A custom JSON encoder for corrections
+Author: Izaak Neutelings (March 2021)
+Description: Write JSON with indents more compactly by collapsing some lists and dictionaries
+Instructions: Print or write JSON dictionary 'data' as
+  import JSONEncoder
+  print(JSONEncoder.write(data,sort_keys=True,indent=2,maxlistlen=25,maxdictlen=3,breakbrackets=False))
+  print(JSONEncoder.dumps(data,sort_keys=True,indent=2,maxlistlen=25,maxdictlen=3,breakbrackets=False))
+Adapted from:
+  https://stackoverflow.com/questions/16264515/json-dumps-custom-formatting
+"""
+
+import gzip
+import json
+import math
+from typing import Any, List, Type  # noqa: F401
+
+import pydantic
+
+
+def write(data: Any, fname: str, **kwargs: Any) -> None:
+    """Help function to quickly write JSON file formatted by JSONEncoder."""
+    if fname.endswith(".json.gz"):
+        with gzip.open(fname, "wt") as fout:
+            fout.write(dumps(data, **kwargs))
+    else:
+        with open(fname, "w") as fout:
+            fout.write(dumps(data, **kwargs))
+
+
+def dumps(data: Any, sort_keys: bool = False, **kwargs: Any) -> str:
+    """Help function to quickly dump dictionary formatted by JSONEncoder."""
+    if isinstance(data, pydantic.BaseModel):  # for pydantic
+        data = data.model_dump(mode="json", exclude_unset=True)
+    return json.dumps(data, cls=JSONEncoder, sort_keys=sort_keys, **kwargs)
+
+
+class JSONEncoder(json.JSONEncoder):
+    """
+    Encoder to make correctionlib JSON more compact, but still readable:
+    - keep list of primitives (int, float, str) on one line,
+      or split over several if the length is longer than a given maxlen
+    - do not break line for short dictionary if all values are primitive
+    - do not break line after bracket for first key of dictionary,
+      unless itself nested in dictionary
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        if kwargs.get("indent", None) is None:
+            kwargs["indent"] = 2
+        # maximum of primitive elements per list, before breaking lines
+        self.maxlistlen = kwargs.pop("maxlistlen", 25)
+        # maximum of primitive elements per dict, before breaking lines
+        self.maxdictlen = kwargs.pop("maxdictlen", 2)
+        # maximum length of strings in short dict, before breaking lines
+        self.maxstrlen = kwargs.pop("maxstrlen", 2 * self.maxlistlen)
+        # break after opening bracket
+        self.breakbrackets = kwargs.pop("breakbrackets", False)
+        super().__init__(*args, **kwargs)
+        self._indent = 0  # current indent
+        self.parent = type(None)  # type of parent for recursive use
+
+    def encode(self, obj: Any) -> str:
+        grandparent = self.parent  # type: Type[Any]
+        self.parent = type(obj)
+        retval = ""
+        if isinstance(obj, (list, tuple)):  # lists, tuples
+            output = []
+            if all(
+                isinstance(x, (int, float, str)) for x in obj
+            ):  # list of primitives only
+                strlen = sum(len(s) for s in obj if isinstance(s, str))
+                indent_str = " " * (self._indent + self.indent)  # type: ignore
+                if strlen > self.maxstrlen and any(
+                    len(s) > 3 for s in obj if isinstance(s, str)
+                ):
+                    obj = [
+                        json.dumps(s) for s in obj
+                    ]  # convert everything into a string
+                    if any(
+                        len(s) > self.maxstrlen / 4 for s in obj
+                    ):  # break list of long strings into multiple lines
+                        output = obj
+                    else:  # group strings into several lines
+                        line = []  # type: List[str]
+                        nchars = 0
+                        for item in obj:
+                            if len(line) == 0 or nchars + len(item) < self.maxstrlen:
+                                line.append(item)
+                                nchars += len(item)
+                            else:  # new line
+                                output.append(", ".join(line))
+                                line = [item]
+                                nchars = len(item)
+                        if line:
+                            output.append(", ".join(line))
+                elif len(obj) <= self.maxlistlen:  # write short list on one line
+                    for item in obj:
+                        output.append(json.dumps(item))
+                    retval = "[ " + ", ".join(output) + " ]"
+                else:  # break long list into multiple lines
+                    nlines = math.ceil(
+                        len(obj) / float(self.maxlistlen)
+                    )  # number of lines
+                    maxlen = int(
+                        math.ceil(len(obj) / nlines)
+                    )  # divide evenly over nlines
+                    for i in range(0, nlines):
+                        line = []
+                        for item in obj[i * maxlen : (i + 1) * maxlen]:
+                            line.append(json.dumps(item))
+                        if line:
+                            output.append(", ".join(line))
+                if not retval:
+                    lines = (",\n" + indent_str).join(output)  # lines between brackets
+                    if (
+                        grandparent is dict or self.breakbrackets
+                    ):  # break first line after opening bracket
+                        retval = (
+                            "[\n" + indent_str + lines + "\n" + " " * self._indent + "]"
+                        )
+                    else:  # do not break first line
+                        retval = (
+                            "["
+                            + " " * (self.indent - 1)  # type: ignore
+                            + lines
+                            + "\n"
+                            + " " * self._indent
+                            + "]"
+                        )
+            else:  # list of lists, tuples, dictionaries
+                self._indent += self.indent  # type: ignore
+                indent_str = " " * self._indent
+                for item in obj:
+                    output.append(indent_str + self.encode(item))
+                self._indent -= self.indent  # type: ignore
+                indent_str = " " * self._indent
+                retval = "[\n" + ",\n".join(output) + "\n" + indent_str + "]"
+        elif isinstance(obj, dict):  # dictionaries
+            output = []
+            if (
+                len(obj) <= self.maxdictlen
+                and all(isinstance(obj[k], (int, float, str)) for k in obj)
+                and sum(len(k) + len(obj[k]) for k in obj if isinstance(obj[k], str))
+                <= self.maxstrlen
+            ):  # write short dict on one line
+                retval = (
+                    "{ "
+                    + ", ".join(json.dumps(k) + ": " + self.encode(obj[k]) for k in obj)
+                    + " }"
+                )
+            else:  # break long dict into multiple line
+                self._indent += self.indent  # type: ignore
+                indent_str = " " * self._indent
+                first = (
+                    grandparent not in (type(None), dict) and not self.breakbrackets
+                )  # break after opening brace
+                for key, value in obj.items():
+                    valstr = self.encode(value)
+                    if (
+                        first and "\n" not in valstr
+                    ):  # no break between opening brace and first key
+                        row = " " * (self.indent - 1) + json.dumps(key) + ": " + valstr  # type: ignore
+                    else:  # break before key
+                        row = "\n" + indent_str + json.dumps(key) + ": " + valstr
+                    output.append(row)
+                    first = False
+                self._indent -= self.indent  # type: ignore
+                indent_str = " " * self._indent
+                retval = "{" + ",".join(output) + "\n" + indent_str + "}"
+        else:  # use default formatting
+            retval = json.dumps(obj)
+        self.parent = grandparent
+        return retval

correctionlib/__init__.py

@@ -0,0 +1,15 @@
+import sys
+
+if sys.platform.startswith("win32"):
+    import ctypes
+
+    from .util import this_module_path
+
+    ctypes.CDLL(str(this_module_path() / "lib" / "correctionlib.dll"))
+
+
+from .binding import register_pyroot_binding
+from .highlevel import Correction, CorrectionSet
+from .version import version as __version__
+
+__all__ = ("__version__", "CorrectionSet", "Correction", "register_pyroot_binding")

correctionlib/_core/__init__.pyi

@@ -0,0 +1,88 @@
+from typing import Any, Dict, Iterator, List, Type, TypeVar, Union
+
+import numpy
+
+class Variable:
+    @property
+    def name(self) -> str: ...
+    @property
+    def description(self) -> str: ...
+    @property
+    def type(self) -> str: ...
+    @staticmethod
+    def from_string(json: str) -> Variable: ...
+
+class CompoundCorrection:
+    @property
+    def name(self) -> str: ...
+    @property
+    def description(self) -> str: ...
+    @property
+    def inputs(self) -> List[Variable]: ...
+    @property
+    def output(self) -> Variable: ...
+    def evaluate(self, *args: Union[str, int, float]) -> float: ...
+    def evalv(
+        self, *args: Union[numpy.ndarray[Any, Any], str, int, float]
+    ) -> numpy.ndarray[Any, numpy.dtype[numpy.float64]]: ...
+
+class Correction:
+    @property
+    def name(self) -> str: ...
+    @property
+    def description(self) -> str: ...
+    @property
+    def version(self) -> int: ...
+    @property
+    def inputs(self) -> List[Variable]: ...
+    @property
+    def output(self) -> Variable: ...
+    def evaluate(self, *args: Union[str, int, float]) -> float: ...
+    def evalv(
+        self, *args: Union[numpy.ndarray[Any, Any], str, int, float]
+    ) -> numpy.ndarray[Any, numpy.dtype[numpy.float64]]: ...
+
+T = TypeVar("T", bound="CorrectionSet")
+
+class CorrectionSet:
+    @classmethod
+    def from_file(cls: Type[T], filename: str) -> T: ...
+    @classmethod
+    def from_string(cls: Type[T], data: str) -> T: ...
+    @property
+    def schema_version(self) -> int: ...
+    @property
+    def description(self) -> str: ...
+    def __getitem__(self, key: str) -> Correction: ...
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[str]: ...
+    @property
+    def compound(self) -> Dict[str, CompoundCorrection]: ...
+
+class FormulaAst:
+    class NodeType:
+        name: str
+        value: int
+
+    class UnaryOp:
+        name: str
+        value: int
+
+    class BinaryOp:
+        name: str
+        value: int
+
+    @property
+    def nodetype(self) -> NodeType: ...
+    @property
+    def data(self) -> Union[None, float, int, UnaryOp, BinaryOp]: ...
+    @property
+    def children(self) -> list[FormulaAst]: ...
+
+class Formula:
+    @property
+    def expression(self) -> str: ...
+    @property
+    def ast(self) -> FormulaAst: ...
+    @classmethod
+    def from_string(cls, data: str, inputs: List[Variable]) -> Formula: ...

correctionlib/binding.py

@@ -0,0 +1,20 @@
+def register_pyroot_binding() -> None:
+    import sys
+
+    from cppyy import gbl
+
+    from .util import artifact_base_dir
+
+    base_path = artifact_base_dir()
+    lib = base_path / "lib"
+
+    # maybe not the most robust solution?
+    if sys.platform.startswith("win32"):
+        lib = lib / "correctionlib.dll"
+    elif sys.platform.startswith("darwin"):
+        lib = lib / "libcorrectionlib.dylib"
+    else:
+        lib = lib / "libcorrectionlib.so"
+    gbl.gSystem.Load(str(lib))
+    gbl.gInterpreter.AddIncludePath(str(base_path / "include"))
+    gbl.gROOT.ProcessLine('#include "correction.h"')

correctionlib/cli.py

@@ -0,0 +1,235 @@
+"""Command-line interface to correctionlib."""
+
+import argparse
+import sys
+
+import pydantic
+from rich.console import Console
+
+import correctionlib.version
+from correctionlib import schemav2
+from correctionlib.highlevel import model_auto, open_auto
+
+
+def validate(console: Console, args: argparse.Namespace) -> int:
+    """Check if all files are valid"""
+    if args.ignore_float_inf:
+        schemav2.IGNORE_FLOAT_INF = True
+    retcode = 0
+    for file in args.files:
+        try:
+            if not args.quiet:
+                console.rule(f"[blue]Validating file {file}")
+            cset = model_auto(open_auto(file))
+            if args.version and cset.schema_version != args.version:
+                raise ValueError(
+                    f"Schema version {cset.schema_version} does not match the required version {args.version}"
+                )
+        except pydantic.ValidationError as ex:
+            if not args.quiet:
+                console.print("[red]Validation error, full information below")
+                print(str(ex))  # noqa: T201
+            retcode = 1
+            if args.failfast:
+                break
+        except BaseException:
+            if not args.quiet:
+                raise
+            retcode = 2
+            if args.failfast:
+                break
+        else:
+            if not args.quiet:
+                console.print("[green]All OK :heavy_check_mark:")
+    return retcode
+
+
+def setup_validate(subparsers):
+    parser = subparsers.add_parser("validate", help=validate.__doc__)
+    parser.set_defaults(command=validate)
+    parser.add_argument(
+        "--quiet",
+        "-q",
+        action="store_true",
+        help="Suppress error printout, only produce a returncode",
+    )
+    parser.add_argument(
+        "--failfast",
+        "-f",
+        action="store_true",
+        help="Fail on first invalid file",
+    )
+    parser.add_argument(
+        "--version",
+        "-v",
+        type=int,
+        default=None,
+        help="Validate against specific schema version",
+    )
+    parser.add_argument(
+        "--ignore-float-inf",
+        action="store_true",
+        help="Disable errors for use of float infinities in bin edges (as required in v2.6 and later)",
+    )
+    parser.add_argument("files", nargs="+", metavar="FILE")
+    return parser
+
+
+def summary(console: Console, args: argparse.Namespace) -> int:
+    if args.ignore_float_inf:
+        schemav2.IGNORE_FLOAT_INF = True
+
+    for file in args.files:
+        console.rule(f"[blue]Corrections in file {file}")
+        cset = model_auto(open_auto(file))
+        console.print(cset)
+    return 0
+
+
+def setup_summary(subparsers):
+    parser = subparsers.add_parser("summary", help="Print a summary of the corrections")
+    parser.set_defaults(command=summary)
+    parser.add_argument(
+        "--ignore-float-inf",
+        action="store_true",
+        help="Disable errors for use of float infinities in bin edges (as required in v2.6 and later)",
+    )
+    parser.add_argument("files", nargs="+", metavar="FILE")
+    return parser
+
+
+def merge(console: Console, args: argparse.Namespace) -> int:
+    cset = model_auto(open_auto(args.files[0]))
+    for file in args.files[1:]:
+        cset2 = model_auto(open_auto(file))
+        if cset2.schema_version != cset.schema_version:
+            console.print("[red]Mixed schema versions detected")
+            return 1
+        for corr2 in cset2.corrections:
+            if any(corr.name == corr2.name for corr in cset.corrections):
+                console.print(
+                    f"[red]Correction {corr2.name!r} from {file} is a duplicate"
+                )
+                return 1
+            cset.corrections.append(corr2)
+        for corr2 in cset2.compound_corrections if cset2.compound_corrections else []:
+            if cset.compound_corrections is None:
+                cset.compound_corrections = []
+            if any(corr.name == corr2.name for corr in cset.compound_corrections):
+                console.print(
+                    f"[red]Compound correction {corr2.name!r} from {file} is a duplicate"
+                )
+                return 1
+            cset.compound_corrections.append(corr2)
+    cset.description = "Merged from " + " ".join(args.files)
+    if args.format == "compact":
+        sys.stdout.write(cset.model_dump_json())
+    elif args.format == "indented":
+        sys.stdout.write(cset.model_dump_json(indent=4) + "\n")
+    elif args.format == "pretty":
+        from correctionlib.JSONEncoder import dumps
+
+        sys.stdout.write(dumps(cset) + "\n")
+    else:
+        return 1
+    return 0
+
+
+def setup_merge(subparsers):
+    parser = subparsers.add_parser(
+        "merge", help="Merge one or more correction files and print to stdout"
+    )
+    parser.set_defaults(command=merge)
+    parser.add_argument(
+        "-f",
+        "--format",
+        type=str,
+        help="JSON output formatting (default: %(default)s)",
+        choices=("compact", "indented", "pretty"),
+        default="compact",
+    )
+    parser.add_argument("files", nargs="+", metavar="FILE")
+    return parser
+
+
+def config(console: Console, args: argparse.Namespace) -> int:
+    from .util import artifact_base_dir
+
+    base_dir = artifact_base_dir()
+    incdir = base_dir / "include"
+    libdir = base_dir / "lib"
+    out = []
+    if args.version:
+        out.append(correctionlib.version.version)
+    if args.incdir:
+        out.append(str(incdir))
+    if args.cflags:
+        out.append(f"-std=c++17 -I{incdir}")
+    if args.libdir:
+        out.append(str(libdir))
+    if args.ldflags:
+        out.append(f"-L{libdir} -lcorrectionlib")
+    if args.rpath:
+        out.append(f"-Wl,-rpath,{libdir}")
+    if args.cmake:
+        out.append(f"-Dcorrectionlib_DIR={base_dir / 'cmake'}")
+    console.out(" ".join(out), highlight=False)
+    return 0
+
+
+def setup_config(subparsers):
+    parser = subparsers.add_parser(
+        "config", help="Configuration and linking information"
+    )
+    parser.set_defaults(command=config)
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="store_true",
+        help="Return correctionlib current version",
+    )
+    parser.add_argument("--incdir", action="store_true")
+    parser.add_argument("--cflags", action="store_true")
+    parser.add_argument("--libdir", action="store_true")
+    parser.add_argument("--ldflags", action="store_true")
+    parser.add_argument(
+        "--rpath", action="store_true", help="Include library path hint in linker"
+    )
+    parser.add_argument("--cmake", action="store_true", help="CMake dependency flags")
+    return parser
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(prog="correction", description=__doc__)
+    parser.add_argument(
+        "--width",
+        type=int,
+        default=100,
+        help="Rich output width",
+    )
+    parser.add_argument("--html", type=str, help="Save terminal output to an HTML file")
+    subparsers = parser.add_subparsers()
+    all_commands = []
+    all_commands.append(setup_validate(subparsers))
+    all_commands.append(setup_summary(subparsers))
+    all_commands.append(setup_merge(subparsers))
+    all_commands.append(setup_config(subparsers))
+    args = parser.parse_args()
+
+    console = Console(width=args.width, record=bool(args.html))
+    if hasattr(args, "command"):
+        retcode: int = args.command(console, args)
+        if args.html:
+            console.save_html(args.html)
+        return retcode
+
+    help = parser.format_help() + "\n"
+    help += "Subcommand usage (specify -h for more detail):\n"
+    for command in all_commands:
+        help += command.format_usage()
+    console.out(help, highlight=False)
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())

correctionlib/cmake/correctionlib-targets-release.cmake

@@ -0,0 +1,19 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "correctionlib" for configuration "Release"
+set_property(TARGET correctionlib APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(correctionlib PROPERTIES
+  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/correctionlib/lib/correctionlib.lib"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/correctionlib/lib/correctionlib.dll"
+  )
+
+list(APPEND _cmake_import_check_targets correctionlib )
+list(APPEND _cmake_import_check_files_for_correctionlib "${_IMPORT_PREFIX}/correctionlib/lib/correctionlib.lib" "${_IMPORT_PREFIX}/correctionlib/lib/correctionlib.dll" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)

correctionlib/cmake/correctionlib-targets.cmake

@@ -0,0 +1,106 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+   message(FATAL_ERROR "CMake >= 2.8.3 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "2.8.3")
+   message(FATAL_ERROR "CMake >= 2.8.3 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 2.8.3...4.1)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS correctionlib)
+  list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+  if(TARGET "${_cmake_expected_target}")
+    list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+  else()
+    list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+  endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+  unset(_cmake_targets_defined)
+  unset(_cmake_targets_not_defined)
+  unset(_cmake_expected_targets)
+  unset(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+  string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+  string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target correctionlib
+add_library(correctionlib SHARED IMPORTED)
+
+set_target_properties(correctionlib PROPERTIES
+  INTERFACE_COMPILE_FEATURES "cxx_std_17"
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/correctionlib/include"
+)
+
+# Load information for each installed configuration.
+file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/correctionlib-targets-*.cmake")
+foreach(_cmake_config_file IN LISTS _cmake_config_files)
+  include("${_cmake_config_file}")
+endforeach()
+unset(_cmake_config_file)
+unset(_cmake_config_files)
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(_cmake_target IN LISTS _cmake_import_check_targets)
+  if(CMAKE_VERSION VERSION_LESS "3.28"
+      OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target}
+      OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}")
+    foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+      if(NOT EXISTS "${_cmake_file}")
+        message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+   \"${_cmake_file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+      endif()
+    endforeach()
+  endif()
+  unset(_cmake_file)
+  unset("_cmake_import_check_files_for_${_cmake_target}")
+endforeach()
+unset(_cmake_target)
+unset(_cmake_import_check_targets)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)

correctionlib/cmake/correctionlibConfig.cmake

@@ -0,0 +1,10 @@
+
+####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() #######
+####### Any changes to this file will be overwritten by the next CMake run ####
+####### The input file was Config.cmake.in                            ########
+
+get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../" ABSOLUTE)
+
+####################################################################################
+
+include("${CMAKE_CURRENT_LIST_DIR}/correctionlib-targets.cmake")