{

public:

/// Default constructor

CalArray() = default;

/// Default destructor

~CalArray() = default;

/// Constructor sets a default name depending on the pad subset type and number

/// \param padSubset pad subset type (e.g. PadSubset::ROC)

/// \param padSubsetNumber number of the pad subset (e.g. 0 for ROC 0)

CalArray(const PadSubset padSubset, const int padSubsetNumber)

: mName(),

mData(),

mPadSubset(padSubset),

mPadSubsetNumber(padSubsetNumber)

{

// initialize the data array

initData();

}

/// Constructor assumes PadSubset::ROC

/// \param name name of the calibration array

/// \param padSubsetNumber number of the pad subset (e.g. 0 for ROC 0)

CalArray(const std::string_view name, const int padSubsetNumber)

: mName(name),

mData(),

mPadSubset(PadSubset::ROC),

mPadSubsetNumber(padSubsetNumber)

{

// initialize the data array

initData();

}

/// Constructor

/// \param name name of the calibration array

/// \param padSubsetNumber number of the pad subset (e.g. 0 for ROC 0)

CalArray(const std::string_view name, const PadSubset padSubset, const int padSubsetNumber)

: mName(name),

mData(),

mPadSubset(padSubset),

mPadSubsetNumber(padSubsetNumber)

{

// initialize the data array

initData();

}

/// Return the pad subset type

/// \return pad subset type

PadSubset getPadSubset() const { return mPadSubset; }

/// Return the pad subset number (e.g. ROC number)

/// \return pad subset number (e.g. ROC number)

int getPadSubsetNumber() const { return mPadSubsetNumber; }

void setValue(const size_t channel, const T& value) { mData[channel] = value; }

const T getValue(const size_t channel) const

{

assert(channel < mData.size());

return mData[channel];

}

void setValue(const size_t row, const size_t pad, const T& value);

const T getValue(const size_t row, const size_t pad) const;

void setName(const std::string& name) { mName = name; }

const std::string& getName() const { return mName; }

const std::vector<T>& getData() const { return mData; }

std::vector<T>& getData() { return mData; }

/// calculate the sum of all elements

template <typename U = T>

const U getSum() const

{

return std::accumulate(mData.begin(), mData.end(), U{});

}

/// Multiply all val to all channels

const CalArray<T>& multiply(const T& val) { return *this *= val; }

/// Add other to this channel by channel

const CalArray& operator+=(const CalArray& other);

/// Subtract other from this channel by channel

const CalArray& operator-=(const CalArray& other);

/// Multiply other to this channel by channel

const CalArray& operator*=(const CalArray& other);

/// Divide this by other channel by channel

const CalArray& operator/=(const CalArray& other);

/// check for equality

bool operator==(const CalArray& other) const;

/// Add value to all channels

const CalArray& operator+=(const T& val);

/// Subtract value from all channels

const CalArray& operator-=(const T& val);

/// Multiply value to all channels

const CalArray& operator*=(const T& val);

/// Divide value on all channels

const CalArray& operator/=(const T& val);

/// assigment to all channls

const CalArray& operator=(const T& val)

{

std::fill(mData.begin(), mData.end(), val);

return *this;

}

template <typename U = T>

U getMean() const

{

const auto& vals = mData;

const U nVal = static_cast<U>(vals.size());

const U sum = std::accumulate(vals.begin(), vals.end(), 0.f);

return (nVal > 0) ? sum / nVal : U{0};

}

private:

std::string mName;

// better to use std::array?

// std::vector<T, Vc::Allocator<T>> mData;

// how to use Vc::Allocator in this case? Specialisation for float, double, etc?

std::vector<T> mData; ///< calibration data

PadSubset mPadSubset; ///< Subset type

int mPadSubsetNumber; ///< Number of the pad subset, e.g. ROC 0 is IROC A00

/// initialize the data array depending on what is set as PadSubset

void initData();