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