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