Variable.h

Go to the documentation of this file.

#pragma once

#include <iostream>
#include <limits>
#include <memory>
#include <string>
#include <vector>

#include <goofit/GlobalCudaDefines.h>
#include <goofit/Log.h>

// Declaring friends

namespace GooFit {

class Params;
class Minuit1;

class Indexable {
  protected:
    std::string name;

    std::shared_ptr<fptype> value;

    std::shared_ptr<fptype> lowerlimit{std::make_shared<fptype>(0)};

    std::shared_ptr<fptype> upperlimit{std::make_shared<fptype>(0)};

    std::shared_ptr<int> index{std::make_shared<int>(-1)};

  public:
    Indexable(std::string n, fptype val = 0)
        : name(n)
        , value(std::make_shared<fptype>(val)) {}

    Indexable(std::string n, fptype val, fptype lowerlimit, fptype upperlimit)
        : name(n)
        , value(std::make_shared<fptype>(val))
        , lowerlimit(std::make_shared<fptype>(lowerlimit))
        , upperlimit(std::make_shared<fptype>(upperlimit)) {}

    Indexable &operator=(const Indexable &) = delete;

    virtual ~Indexable() {
        if(value.use_count() == 1)
            GOOFIT_DEBUG("Destroying Indexable: {}", name);
    }

    int getIndex() const { return *index; }
    void setIndex(int value) { *index = value; }

    const std::string &getName() const { return name; }
    // The name cannot be changed
    // void setName(const std::string &val) { name = val; }

    fptype getValue() const { return *value; }
    void setValue(fptype val) { *value = val; }

    fptype getUpperLimit() const { return *upperlimit; }
    void setUpperLimit(fptype val) { *upperlimit = val; }

    fptype getLowerLimit() const { return *lowerlimit; }
    void setLowerLimit(fptype val) { *lowerlimit = val; }

    const Indexable &operator=(const fptype &val) {
        setValue(val);
        return *this;
    }

    // Utilities

    operator fptype() const { return getValue(); }

    bool operator<(const Indexable &other) const { return value.get() < other.value.get(); }

    bool operator==(const Indexable &other) const { return value.get() == other.value.get(); }

    bool operator!=(const Indexable &other) const { return value.get() != other.value.get(); }

    operator bool() const {
        return getUpperLimit() == getLowerLimit() || (getValue() <= getUpperLimit() && getValue() >= getLowerLimit());
    }
};

class Observable : public Indexable {
    friend std::istream &operator>>(std::istream &o, Observable &var);

  protected:
    std::shared_ptr<size_t> numbins{std::make_shared<size_t>(100)};

    bool is_event_number{false};

  public:
    Observable(std::string name, fptype lowerlimit, fptype upperlimit)
        : GooFit::Indexable(name, 0, lowerlimit, upperlimit) {}

    ~Observable() override = default;

    Observable &operator=(const Observable &) = delete;

    void setNumBins(size_t num) { *numbins = num; }
    size_t getNumBins() const { return *numbins; }

    fptype getBinSize() const { return (getUpperLimit() - getLowerLimit()) / getNumBins(); }

    bool isEventNumber() const { return is_event_number; }

    const Observable &operator=(const fptype &val) {
        setValue(val);
        return *this;
    }
};

class Variable : public Indexable {
    friend std::ostream &operator<<(std::ostream &o, const Variable &var);

  public:
    class Key {
        friend Params;
        friend Minuit1;

        Key() = default;
    };

    // These classes can now be duplicated safely. No pointers needed.
    Variable(const Variable &) = default;
    Variable(Variable &&)      = default;

    Variable(std::string n, fptype v)
        : Indexable(n, v, v + 0.01, v - 0.01)
        , error(std::make_shared<fptype>(0.002)) {
        *fixed = true;
    }

    Variable(std::string n, fptype v, fptype dn, fptype up)
        : Indexable(n, v, dn, up)
        , error(std::make_shared<fptype>(0.1 * (up - dn))) {}

    Variable(std::string n, fptype v, fptype e, fptype dn, fptype up, bool fix = false)
        : Indexable(n, v, dn, up)
        , error(std::make_shared<fptype>(e))
        , fixed(std::make_shared<bool>(fix)) {}

    ~Variable() override = default;

    Variable &operator=(const Variable &) = delete;

    fptype getError() const { return *error; }
    void setError(fptype val) { *error = val; }

    int getFitterIndex() const { return *fitter_index; }
    void setFitterIndex(int value) { *fitter_index = value; }

    bool getChanged() const { return *changed_; }

    bool IsFixed() const { return *fixed; }

    void setFixed(bool fix) { *fixed = fix; }

    void setChanged(bool val = true) { *changed_ = val; }

    void setBlind(fptype val) { *blind = val; }

    fptype getBlind(const Key &) { return *blind; }

    const Variable &operator=(const fptype &val) {
        setValue(val);
        return *this;
    }

  protected:
    std::shared_ptr<fptype> error;

    std::shared_ptr<fptype> blind{std::make_shared<fptype>(0)};

    std::shared_ptr<bool> changed_{std::make_shared<bool>(true)};

    std::shared_ptr<bool> fixed{std::make_shared<bool>(false)};

    std::shared_ptr<int> fitter_index{std::make_shared<int>(-1)};
};

class EventNumber : public Observable {
  public:
    static constexpr fptype maxint{1L << std::numeric_limits<fptype>::digits};

    EventNumber(std::string name, fptype min = 0, fptype max = EventNumber::maxint)
        : GooFit::Observable(name, min, max) {
        is_event_number = true;
        *value          = 0; // Start with 0 event number by default
    }

    ~EventNumber() override = default;

    EventNumber &operator=(const EventNumber &) = delete;

    const EventNumber &operator=(const fptype &val) {
        setValue(val);
        return *this;
    }
};

int max_index(const std::vector<Variable> &vars);
int max_index(const std::vector<Observable> &vars);

int max_fitter_index(const std::vector<Variable> &vars);

std::ostream &operator<<(std::ostream &o, const GooFit::Variable &var);

std::ostream &operator<<(std::ostream &o, const GooFit::Observable &var);

std::istream &operator>>(std::istream &i, GooFit::Observable &var);
} // namespace GooFit