File indexing completed on 2026-04-04 08:08:17
0001 #ifndef __WRAPPER_FIT_FINAL_ARRAYS_H__
0002 #define __WRAPPER_FIT_FINAL_ARRAYS_H__
0003
0004 #include "AsymmetryCalc/Constants.h"
0005
0006 #include <iostream>
0007 #include <array>
0008 #include <string>
0009 #include <cstdlib>
0010 #include <cstdint>
0011
0012 namespace AsymmetryCalc {
0013 class pt_final_array {
0014 public:
0015 static constexpr int nDimensions = 3;
0016
0017 static constexpr size_t dim_sizes[nDimensions] = {ASYM_CONSTANTS::nParticles, ASYM_CONSTANTS::nPtBins, ASYM_CONSTANTS::nDirections};
0018
0019 static constexpr const char* dim_names[nDimensions] = {"particle", "pt", "direction"};
0020
0021 static constexpr size_t size_array = dim_sizes[0] * dim_sizes[1] * dim_sizes[2];
0022
0023 using storage_type = std::array<double, size_array>;
0024
0025 double& operator()(size_t iParticle,
0026 size_t iPt,
0027 size_t iDir)
0028 {
0029 check_bounds(iParticle, iPt, iDir);
0030 return data_[index(iParticle, iPt, iDir)];
0031 }
0032
0033 const double& operator()(size_t iParticle,
0034 size_t iPt,
0035 size_t iDir) const
0036
0037 {
0038 check_bounds(iParticle, iPt, iDir);
0039 return data_[index(iParticle, iPt, iDir)];
0040 }
0041
0042 private:
0043
0044 storage_type data_{};
0045
0046 void check_bounds(size_t iParticle,
0047 size_t iPt,
0048 size_t iDir) const
0049 {
0050 size_t indices[nDimensions] = {iParticle, iPt, iDir};
0051 for (int iDim = 0; iDim < nDimensions; iDim++)
0052 {
0053 if (indices[iDim] > dim_sizes[iDim])
0054 {
0055 std::cerr << "Error: " << dim_names[iDim] << " index out of bounds" << std::endl;
0056 std::exit(1);
0057 }
0058 }
0059 }
0060
0061 static constexpr size_t index(size_t iParticle,
0062 size_t iPt,
0063 size_t iDir)
0064 {
0065 return (((iParticle)
0066 * ASYM_CONSTANTS::nPtBins + iPt)
0067 * ASYM_CONSTANTS::nDirections + iDir);
0068 }
0069 };
0070
0071 class pt_nodir_final_array {
0072 public:
0073 static constexpr int nDimensions = 2;
0074
0075 static constexpr size_t dim_sizes[nDimensions] = {ASYM_CONSTANTS::nParticles, ASYM_CONSTANTS::nPtBins};
0076
0077 static constexpr const char* dim_names[nDimensions] = {"particle", "pt"};
0078
0079 static constexpr size_t size_array = dim_sizes[0] * dim_sizes[1];
0080
0081 using storage_type = std::array<double, size_array>;
0082
0083 double& operator()(size_t iParticle,
0084 size_t iPt)
0085 {
0086 check_bounds(iParticle, iPt);
0087 return data_[index(iParticle, iPt)];
0088 }
0089
0090 const double& operator()(size_t iParticle,
0091 size_t iPt) const
0092
0093 {
0094 check_bounds(iParticle, iPt);
0095 return data_[index(iParticle, iPt)];
0096 }
0097
0098 private:
0099
0100 storage_type data_{};
0101
0102 void check_bounds(size_t iParticle,
0103 size_t iPt) const
0104 {
0105 size_t indices[nDimensions] = {iParticle, iPt};
0106 for (int iDim = 0; iDim < nDimensions; iDim++)
0107 {
0108 if (indices[iDim] > dim_sizes[iDim])
0109 {
0110 std::cerr << "Error: " << dim_names[iDim] << " index out of bounds" << std::endl;
0111 std::exit(1);
0112 }
0113 }
0114 }
0115
0116 static constexpr size_t index(size_t iParticle,
0117 size_t iPt)
0118 {
0119 return ((iParticle)
0120 * ASYM_CONSTANTS::nPtBins + iPt);
0121 }
0122 };
0123
0124 class eta_final_array {
0125 public:
0126 static constexpr int nDimensions = 2;
0127
0128 static constexpr size_t dim_sizes[nDimensions] = {ASYM_CONSTANTS::nParticles, ASYM_CONSTANTS::nEtaBins};
0129
0130 static constexpr const char* dim_names[nDimensions] = {"particle", "eta"};
0131
0132 static constexpr size_t size_array = dim_sizes[0] * dim_sizes[1];
0133
0134 using storage_type = std::array<double, size_array>;
0135
0136 double& operator()(size_t iParticle,
0137 size_t iEta)
0138 {
0139 check_bounds(iParticle, iEta);
0140 return data_[index(iParticle, iEta)];
0141 }
0142
0143 const double& operator()(size_t iParticle,
0144 size_t iEta) const
0145 {
0146 check_bounds(iParticle, iEta);
0147 return data_[index(iParticle, iEta)];
0148 }
0149
0150 private:
0151
0152 storage_type data_{};
0153
0154 void check_bounds(size_t iParticle,
0155 size_t iEta) const
0156 {
0157 size_t indices[nDimensions] = {iParticle, iEta};
0158 for (int iDim = 0; iDim < nDimensions; iDim++)
0159 {
0160 if (indices[iDim] > dim_sizes[iDim])
0161 {
0162 std::cerr << "Error: " << dim_names[iDim] << " index out of bounds" << std::endl;
0163 std::exit(1);
0164 }
0165 }
0166 }
0167
0168 static constexpr size_t index(size_t iParticle,
0169 size_t iEta)
0170 {
0171 return ((iParticle)
0172 * ASYM_CONSTANTS::nEtaBins + iEta);
0173 }
0174 };
0175
0176 class xf_final_array {
0177 public:
0178 static constexpr int nDimensions = 2;
0179
0180 static constexpr size_t dim_sizes[nDimensions] = {ASYM_CONSTANTS::nParticles, ASYM_CONSTANTS::nXfBins};
0181
0182 static constexpr const char* dim_names[nDimensions] = {"particle", "xf"};
0183
0184 static constexpr size_t size_array = dim_sizes[0] * dim_sizes[1];
0185
0186 using storage_type = std::array<double, size_array>;
0187
0188 double& operator()(size_t iParticle,
0189 size_t iXf)
0190 {
0191 check_bounds(iParticle, iXf);
0192 return data_[index(iParticle, iXf)];
0193 }
0194
0195 const double& operator()(size_t iParticle,
0196 size_t iXf) const
0197 {
0198 check_bounds(iParticle, iXf);
0199 return data_[index(iParticle, iXf)];
0200 }
0201
0202 private:
0203
0204 storage_type data_{};
0205
0206 void check_bounds(size_t iParticle,
0207 size_t iXf) const
0208 {
0209 size_t indices[nDimensions] = {iParticle, iXf};
0210 for (int iDim = 0; iDim < nDimensions; iDim++)
0211 {
0212 if (indices[iDim] > dim_sizes[iDim])
0213 {
0214 std::cerr << "Error: " << dim_names[iDim] << " index out of bounds" << std::endl;
0215 std::exit(1);
0216 }
0217 }
0218 }
0219
0220 static constexpr size_t index(size_t iParticle,
0221 size_t iXf)
0222 {
0223 return ((iParticle)
0224 * ASYM_CONSTANTS::nXfBins + iXf);
0225 }
0226 };
0227 };
0228
0229 #endif
