sPhenix code displayed by LXR |
|
|
|
|||
File indexing completed on 2026-10-15 08:17:26
0001 // 0002 //---- fluct_common.h (PairTypes Definition REMOVED!) 0003 //---- main definitions used by many codes and macros... 0004 // 0005 #include <vector> 0006 #include <utility> 0007 #include <cmath> 0008 //---- TPC-only bits of `layermask` (README_SplitTracks.md sec 9.1/9.2): bits 0-2 are MVTX, 0009 //---- 3-6 are INTT, 7-54 are TPC. The STAR SL formula (sec 9.2/6) must run on the TPC portion 0010 //---- only -- masking out the silicon bits, which every genuine split pair shares by 0011 //---- construction (same seed), would otherwise bias SL for every pair. 0012 static const ULong64_t kTPCLayerMask = ((1ULL<<48)-1) << 7; 0013 // 0014 //---- STAR-style pairwise Splitting Level (arXiv:nucl-ex/0411036 sec 2.4.1), computed from two 0015 //---- tracks' TPC pad-row occupancy masks. SL=-0.5 means the pair shares essentially every TPC 0016 //---- pad-row hit (one real track, split); SL=1.0 means no shared pad-rows (two independent 0017 //---- tracks). Callers must treat hitmask==0 as "not a real track" (e.g. a V0 slot, sec 10.2) 0018 //---- and skip this function in that case -- it has no way to detect that condition itself. 0019 //---- Shared by CalcRm::ComputeSL and corral_loop.cxx's split-track SL monitor (sec 10.7/10.9) 0020 //---- so the formula only lives in one place. 0021 static inline double ComputeSplitSL(ULong64_t maskA, ULong64_t maskB){ 0022 ULong64_t a = maskA & kTPCLayerMask; 0023 ULong64_t b = maskB & kTPCLayerMask; 0024 int Nboth = __builtin_popcountll(a & b); 0025 int Ndiff = __builtin_popcountll(a ^ b); 0026 int Ntot = __builtin_popcountll(a) + __builtin_popcountll(b); 0027 if (Ntot==0) return 1.0; // no TPC hits on either leg -- can't judge splitting, don't cut 0028 return ((double)(Ndiff - Nboth)) / ((double)Ntot); 0029 } 0030 // 0031 //---- RadialGap (README_SplitTracks.md sec 17.11): SL above only sees pad-row OVERLAP, so it is 0032 //---- structurally blind to a clean STAR-fig-1b radial split (one real track, TPC clusters 0033 //---- partitioned into disjoint inner/outer halves) -- that forces Nboth=0, Ndiff=Ntot, SL=+1 0034 //---- exactly, indistinguishable from two genuinely independent tracks. RadialGap looks at what 0035 //---- SL discards: the TPC bit INDEX itself (bits 7-54, sec 9.1) maps directly to physical 0036 //---- pad-row/radius, so this measures how cleanly the two legs' occupied layers separate by 0037 //---- radius -- |mean layer index[A] - mean layer index[B]|, normalized to [0,1] by the 47-layer 0038 //---- span (0 = no radial separation between the legs' mean hit radius, ~1 = fully separated, 0039 //---- inner vs outer half of the TPC). Returns -1.0 (undefined, caller must skip) if either leg 0040 //---- has zero TPC hits, same convention as SiSplitScore's -1.0. 0041 static inline double ComputeRadialGap(ULong64_t maskA, ULong64_t maskB){ 0042 ULong64_t a = maskA & kTPCLayerMask; 0043 ULong64_t b = maskB & kTPCLayerMask; 0044 double sumA=0,sumB=0; int nA=0,nB=0; 0045 for (int L=0; L<48; L++){ 0046 if (a & (1ULL<<(7+L))){ sumA+=L; ++nA; } 0047 if (b & (1ULL<<(7+L))){ sumB+=L; ++nB; } 0048 } 0049 if (nA==0 || nB==0) return -1.0; 0050 return fabs(sumA/nA - sumB/nB) / 47.0; 0051 } 0052 // 0053 //---- Si (MVTX+INTT) bits of `layermask`, bits 0-6 -- see 9.1. A genuine split pair is built on 0054 //---- one identical silicon seed by construction (sec 3/9.4), so an *exact* bit-for-bit match here 0055 //---- is a much sharper same-track signature than TPC-only SL alone: two independent, well- 0056 //---- reconstructed tracks routinely share most of their ~48 TPC layers just by detector geometry 0057 //---- (2026-09-20 measurement: 95% Si-match rate for real split candidates vs. only 14% for 0058 //---- manifestly-unrelated same-charge pairs, far tighter than SL's own separation). Used as a 0059 //---- pre-filter alongside SL (2026-09-20 hybrid cut, README sec 10.9 update) rather than SL alone, 0060 //---- which was found to reject ~99% of unrelated pairs too at any threshold that actually 0061 //---- suppresses the (0,0) spike -- collateral damage the Si-match requirement avoids. 0062 static const ULong64_t kSiLayerMask = (1ULL<<7)-1; 0063 static inline bool SiSeedMatch(ULong64_t maskA, ULong64_t maskB){ 0064 return (maskA & kSiLayerMask) == (maskB & kSiLayerMask); 0065 } 0066 // 0067 //---- SiKeyFrac: a real hit-IDENTITY check from `siclukey` (README_SplitTracks.md sec 12a.4/ 0068 //---- 13.x), not just a coverage-pattern match like SiSeedMatch above. Graded fraction of the 0069 //---- 7 Si layer slots where the two legs' cluster keys are bit-for-bit identical, over the 0070 //---- slots either leg actually has a hit in. keyA/keyB point at a track's 7-slot siclukey row 0071 //---- (flattened [itrk*7+slot] convention, sec 13.2); maskA/maskB are the tracks' full 0072 //---- layermask (only bits 0-6 consulted here). Standalone close(|deta|<0.01,|dphi|<0.03)-vs- 0073 //---- far(|deta|>0.3) measurement (2026-09-21, two runs, ~100k events each, cross-validated): 0074 //---- SiKeyFrac>=0.6 catches 97.0% of close/likely-split pairs (vs SiSeedMatch's 94.6%) while 0075 //---- false-flagging only 0.003% of far/independent pairs (vs SiSeedMatch's 13.9%) -- SiSeedMatch's 0076 //---- false-positive rate is confirmed to be almost entirely "coincidental full Si coverage," 0077 //---- not real shared-cluster identity (cross-tab: of far-population pairs SiSeedMatch flags, 0078 //---- ~0% also have high SiKeyFrac). Returns -1.0 if neither leg has any Si hit at all 0079 //---- (undefined -- caller must skip, same convention as ComputeSplitSL returning 1.0 for 0080 //---- "no TPC hits on either leg"). 0081 static const ULong64_t kSiKeySentinel = ~0ULL; // "no cluster in this Si slot", sec 12a.1 -- NOT 0 0082 static inline double SiKeyFrac(const ULong64_t *keyA, const ULong64_t *keyB, 0083 ULong64_t maskA, ULong64_t maskB){ 0084 int num=0, den=0; 0085 for (int L=0; L<7; L++){ 0086 bool haveA = (maskA>>L) & 1ULL; 0087 bool haveB = (maskB>>L) & 1ULL; 0088 if (haveA || haveB) ++den; 0089 if (keyA[L]==keyB[L] && keyA[L]!=kSiKeySentinel) ++num; 0090 } 0091 if (den==0) return -1.0; 0092 return ((double)num) / ((double)den); 0093 } 0094 // 0095 //---- SiKeyFracSplit: exploratory split of the above into an MVTX-only (slots 0-2) and an 0096 //---- INTT-only (slots 3-6) fraction (README_SplitTracks.md sec 13.9 -- the flagged-but-unacted 0097 //---- MVTX/INTT equal-weighting concern, sec 13.8's closing update). MVTX pixels (~27x29um) are 0098 //---- ~1000x finer than an INTT strip's long dimension (78umx16-20mm), so an accidental match on 0099 //---- an INTT slot between two UNRELATED tracks is intrinsically far more likely than on an MVTX 0100 //---- slot, yet the combined SiKeyFrac above weighs a matched slot of either type identically and 0101 //---- floats its denominator (an INTT-only 4/4 match reports the same 1.0 as a true 7/7 match). 0102 //---- Diagnostic only right now -- not wired into any cut, purely for measuring how much this 0103 //---- actually matters before deciding whether/how to build a resolution-aware replacement. 0104 //---- den==0 (no hit on either leg, either sub-detector) reported as -1.0, same sentinel 0105 //---- convention as SiKeyFrac above. 0106 static inline void SiKeyFracSplit(const ULong64_t *keyA, const ULong64_t *keyB, 0107 ULong64_t maskA, ULong64_t maskB, 0108 double &mvtxFrac, int &mvtxDen, 0109 double &inttFrac, int &inttDen){ 0110 int numM=0, denM=0, numI=0, denI=0; 0111 for (int L=0; L<7; L++){ 0112 bool haveA = (maskA>>L) & 1ULL; 0113 bool haveB = (maskB>>L) & 1ULL; 0114 bool have = haveA || haveB; 0115 bool match = (keyA[L]==keyB[L] && keyA[L]!=kSiKeySentinel); 0116 if (L<3){ // MVTX: layermask bits 0-2 0117 if (have) ++denM; 0118 if (match) ++numM; 0119 } else { // INTT: layermask bits 3-6 0120 if (have) ++denI; 0121 if (match) ++numI; 0122 } 0123 } 0124 mvtxDen = denM; 0125 inttDen = denI; 0126 mvtxFrac = (denM>0) ? ((double)numM/denM) : -1.0; 0127 inttFrac = (denI>0) ? ((double)numI/denI) : -1.0; 0128 } 0129 // 0130 //---- SiSplitScore: MVTX-primary, INTT-secondary split-track discriminator 0131 //---- (README_SplitTracks.md sec 13.9) -- REPLACES the plain, unweighted SiKeyFrac() above as 0132 //---- the production pre-pass discriminator (corral_loop.cxx). Direct data-driven design from 0133 //---- a 152,432-candidate measurement (sec 13.9): MVTX evidence is (a) ALWAYS available in the 0134 //---- candidate population (mvtxDen is 2 or 3 for every single measured candidate, never 0-1) 0135 //---- and (b) far more reliable than INTT as standalone evidence. Both effects are real, small, 0136 //---- and directionally exactly what MVTX's ~1000x-finer pixel granularity predicts (an 0137 //---- accidental INTT-strip coincidence between unrelated tracks is far likelier than an 0138 //---- accidental MVTX-pixel one): when MVTX unambiguously reads "no match" (mvtxFrac==0), INTT 0139 //---- alone would spuriously agree ("full match") 5.1% of the time; when MVTX unambiguously 0140 //---- reads "exact match" (mvtxFrac==1), INTT alone would spuriously disagree ("zero overlap") 0141 //---- 8.0% of the time. So this discriminator trusts MVTX's own unambiguous calls outright, and 0142 //---- only consults INTT to break a tie when MVTX itself is genuinely partial (denM==3 only: 0143 //---- 1/3 or 2/3 -- denM==2 has no middle value). Returns -1.0 (undefined, caller must skip) only 0144 //---- in the never-yet-observed case of zero MVTX evidence on either leg, falling back to INTT 0145 //---- alone as the best signal left in that case. 0146 static inline double SiSplitScore(const ULong64_t *keyA, const ULong64_t *keyB, 0147 ULong64_t maskA, ULong64_t maskB){ 0148 double mvtxFrac,inttFrac; int mvtxDen,inttDen; 0149 SiKeyFracSplit(keyA,keyB,maskA,maskB,mvtxFrac,mvtxDen,inttFrac,inttDen); 0150 if (mvtxDen==0) return inttFrac; // not observed in sec 13.9's measurement, kept for 0151 // safety -- itself -1.0 if inttDen==0 too 0152 if (mvtxFrac<=0.0) return 0.0; // MVTX unambiguous "no match" -- trust it, ignore INTT 0153 if (mvtxFrac>=1.0) return 1.0; // MVTX unambiguous "exact match" -- trust it, ignore INTT 0154 if (inttDen==0) return mvtxFrac; // genuinely partial MVTX, no INTT evidence either 0155 return 0.5*(mvtxFrac+inttFrac); // genuinely partial MVTX -- let INTT corroborate 0156 } 0157 // 0158 static const int NSpecies = 8; 0159 static const double Species_mass[NSpecies] = {0.13956995,0.493677,0.93827231,0.9395654133,1.87561339, 0160 0.497763,1.115,1.115 }; //,2.80925,2.80923,3.727417}; 0161 // 0162 static const char *SpeciesNames[NSpecies] = {"#pi", "K", "p", "n", "d", //, "t","^{3}He","#alpha"}; 0163 "K^{0}_{S}","#Lambda_{0}","#bar{#Lambda}_{0}" }; 0164 // 0165 //---- README_PID.md sec 11: V0 mass peaks (ana573, fit gaus+pol2 to hKSmass/hLAmass/hALmass, PID573_v4_mask2). A track is 0166 //---- treated as a V0 daughter (kept out of the pair types) only if its V0 is within +-V0PEAK_NSIG sigma of the peak. 0167 static const double V0PEAK_MU[3] = { 0.4884, 1.1143, 1.1134 }; // K0s, Lambda, Lbar (GeV) 0168 static const double V0PEAK_SIG[3] = { 0.0076, 0.0035, 0.0028 }; 0169 static const double V0PEAK_NSIG = 3.0; 0170 //---- README_PID.md sec 10.3: ana573 vertex-phi windows (deg) of large abs(dca), fixed at the silicon radius; for THIS data only 0171 //---- the first NSIPHIMASK_MAIN are the two big ones (default); "siphimaskall" adds the six small ones (sec 10.4: track dips 0172 //---- at 0.5-0.8 of the local level, most with a DCA spike) 0173 //---- README_SplitTracks573 sec 38: the TPC central-membrane hole: centre at eta = -CMMASK_K vtxz (hetazvtx, ana573) 0174 static const double CMMASK_K = 0.018; 0175 static const int NSIPHIMASK_MAIN = 2; 0176 static const int NSIPHIMASK = 8; 0177 static const double SIPHIMASK_LO[NSIPHIMASK] = { 70., 94., -23., -6., 26., 43., 55., 157.}; 0178 static const double SIPHIMASK_HI[NSIPHIMASK] = { 83.,115., -18., -2., 31., 47., 57., 161.}; 0179 static const double Species_ptmin[NSpecies] = { 0.1, 0.1, 0.4, 0.1, 0.1, 0.1, 0.1, 0.1 }; // p, pbar: 0.4 (README_PID sec 10.1, spallation; STAR PTLL) //, 1.2, 1.2, 1.6}; 0180 static const double Species_ptmax[NSpecies] = { 20.1, 20.1,20.1,20.1, 20.1, 20.1,20.1,20.1 }; //, 4.0, 4.0, 4.0}; 0181 // static const double Species_pmax_dedx[NSpecies] = { 0.7, 0.7, 1.0, 1.5, 8.0, 8.0, 8.0}; 0182 //---- README_PID.md (2026-09-28): ptot cap (GeV/c) for the dE/dx PID (pi 5 = the gates' own limit). It also sets 0183 //---- each species' y window in CalcRm: y at this p at the eta edge = the whole y reach (V0 entries unused). 0184 static const double Species_pmax_pid[NSpecies] = { 5.0, 0.6, 1.0, 5.0, 5.0, 5.0, 5.0, 5.0 }; 0185 //---- 2026-09-30 (user): the rapidity window of each species, abs(y) < Species_yu (YL = -YU). A pair type uses the window of each 0186 //---- of its two species; the y bin width (y1, y2 and dy) is per pair type in PairTypes.h (PairTypes_Info[][3]). 0187 //---- 2026-10-05 (user): K 0.65 -> 0.7 (= the V0s), so K-V0 pairs can share a coarse bin width (1.3 only shares 0.05, 0.1). 0188 static const double Species_yu[NSpecies] = { 1.0, 0.7, 0.6, 0.6, 0.6, 0.7, 0.7, 0.7 }; 0189 //---- 2026-10-11 (user): h+, h- use pseudorapidity over the whole track acceptance, abs(eta) < 1.1 (= the eta fiducial) 0190 static const double Hadron_etau = 1.1; 0191 //---- R2yy(dy) from the (y1,y2) map (a cross-check only; physics is (dy,dphi)): the fraction of a (y1,y2) cell of widths w1, w2 0192 //---- centred at c1, c2 that falls in each bin of a dy axis (nb bins from lo, width bw), by sub-sampling the cell. With equal 0193 //---- widths and bw = w1 the cell centre lands on a dy bin centre: the caller uses that bin alone. 0194 inline void DyOverlap(double c1, double w1, double c2, double w2, int nb, double lo, double bw, std::vector<std::pair<int,double>>& out){ 0195 out.clear(); 0196 const int NS = 20; 0197 std::vector<double> f(nb+2,0.); 0198 for (int i=0;i<NS;i++) for (int j=0;j<NS;j++){ 0199 double dy = (c1 + w1*((i+0.5)/NS-0.5)) - (c2 + w2*((j+0.5)/NS-0.5)); 0200 int b = (int)floor((dy-lo)/bw) + 1; 0201 if (b>=1 && b<=nb) f[b] += 1./(NS*NS); 0202 } 0203 for (int b=1;b<=nb;b++) if (f[b]>0.) out.push_back({b,f[b]}); 0204 } 0205 // static const double Species_pmax_tof[NSpecies] = { 1.7, 1.7, 2.9, 4.0, 8.0, 8.0, 8.0}; 0206 // static const double Species_pmax_dedx_FXT[NSpecies] = { 1.3, 0.6, 2.9, 2.5, 3.4, 8.0, 8.0}; 0207 // static const double Species_pmax_tof_FXT[NSpecies] = { 1.8, 1.8, 4.0, 5.0, 6.0, 8.0, 8.0}; 0208 // 0209 static const double Species_Charge[NSpecies] = { 1, 1, 1, 0, 1, 0,0,0}; //, 1, 2, 2}; 0210 static const double Species_Z[NSpecies] = { 0, 0, 1, 0, 1, 0,0,0}; //, 1, 2, 2}; 0211 static const double Species_A[NSpecies] = { 0, 0, 1, 1, 2, 0,0,0}; //, 3, 3, 4}; 0212 // 0213 // static const double Species_Ddedxcut[NSpecies] = { 0, 0, 0, 1, 1, 3, 2}; 0214 // static const double Species_bichdiffcutu[NSpecies] = { 0, 0.0, 0.0, 1.0, 1.1, 1.0, 1.0}; 0215 // static const double Species_bichdiffcutd[NSpecies] = { 0, 0.0, 0.0, 1.0, 1.1, 1.0, 1.0}; 0216 // static const double Species_ynbfxt[NSpecies] = { 28, 24, 22, 16, 18, 18, 16}; 0217 // static const double Species_ylfxt[NSpecies] = {-1.0,-1.0,-1.0,-1.0,-1.0,-1.0,-1.0}; 0218 // static const double Species_yufxt[NSpecies] = { 0.4, 0.2, 0.1,-0.2,-0.1,-0.1,-0.2}; 0219 // 0220 // ParticleID = SpeciesID for chg>0, and =SpeciesID+NSpecies for chg<0 0221 // 0222 //---- 2026-10-11 (user): h+, h- = every accepted charged track, the dE/dx PID ignored (charged-hadron CFs, as in the 0223 //---- many h+/h- papers). Pion pT cut and mass (GetSpecies -> pion), but in PSEUDORAPIDITY, abs(eta) < Hadron_etau: the loop 0224 //---- passes eta, and CalcRm (fUseEta, from the pid) builds the 4-momenta from eta with the pion mass. 0225 static const int NPARTICLENAMES = 15; 0226 static const int kParticleIDPionPlus = 0; 0227 static const int kParticleIDKaonPlus = 1; 0228 static const int kParticleIDProton = 2; 0229 static const int kParticleIDNeutron = 3; 0230 static const int kParticleIDDeuteron = 4; 0231 static const int kParticleIDPionMinus = 5; 0232 static const int kParticleIDKaonMinus = 6; 0233 static const int kParticleIDAntiProton = 7; 0234 static const int kParticleIDAntiNeutron = 8; 0235 static const int kParticleIDAntiDeuteron = 9; 0236 static const int kParticleIDKshort = 10; 0237 static const int kParticleIDLambda = 11; 0238 static const int kParticleIDAntiLambda = 12; 0239 static const int kParticleIDhPlus = 13; 0240 static const int kParticleIDhMinus = 14; 0241 inline bool IsHadronParticleID(int ipid){ return ipid==kParticleIDhPlus || ipid==kParticleIDhMinus; } // h+, h-: eta, not y 0242 inline bool IsV0ParticleID(int ipid){ return ipid==kParticleIDKshort || ipid==kParticleIDLambda || ipid==kParticleIDAntiLambda; } 0243 // static const int kParticleIDTritonPlus = 5; 0244 // static const int kParticleID3HePlus = 6; 0245 // static const int kParticleID4HePlus = 7; 0246 // static const int kParticleIDTritonMinus = 13; 0247 // static const int kParticleID3HeMinus = 14; 0248 // static const int kParticleID4HeMinus = 15; 0249 static const char *ParticleIDNames[NPARTICLENAMES] = {"#pi+", "K+", "p" , "n" , "d" , // "t+","^{3}He+","#alpha+", 0250 "#pi-", "K-", "#bar{p}", "#bar{n}", "#bar{d}", // "t-","^{3}He-","#alpha-" 0251 "K^{0}_{S}","#Lambda_{0}","#bar{#Lambda}_{0}", "h+", "h-" }; 0252 static const int ParticlePDGids[NPARTICLENAMES] = { 211, 321, 2212, 2112, 1000010020, // 1000010030, 1000020030, 1000020040, 0253 -211,-321,-2212,-2112,-1000010020, // -1000010030,-1000020030,-1000020040 0254 310, 3122, -3122, 0, 0}; // h+, h-: no PDG id 0255 static const int ParticleBaryNum[NPARTICLENAMES]= { 0, 0, 1, 1, 2, // 1000010030, 1000020030, 1000020040, 0256 0, 0, -1, -1, -2, // -1000010030,-1000020030,-1000020040 0257 0, 1, -1, 0, 0 }; 0258 static const int ParticleCharge[NPARTICLENAMES]= { 1,1,1,1,1, // 1000010030, 1000020030, 1000020040, 0259 -1,-1,-1,-1,-1, // -1000010030,-1000020030,-1000020040 0260 0, 0, 0, 1, -1 }; 0261 // 0262 // 0263 static const int NR2TYPES = 3; // used in reader to get hists. Also defined in class CalcRm - ensure consistency!!! 0264 // 0265 static const int NTRIGS = 39; 0266 static const char* TrigNames[64] = { "Clock", // 0 0267 "ZDCs", // 1 0268 "ZDCn", // 2 0269 "ZDCns", // 3 0270 "HCAL Singles/Coincidence", // 4 0271 "Clock2", // 5 0272 "", // 6 0273 "", // 7 0274 "MBDs>0", // 8 0275 "MBDn>0", // 9 0276 "MBDns>0", //10 0277 "MBDns>1", //11 0278 "MBDns>0+vtx<10", //12 0279 "MBDns>0+vtx<30", //13 0280 "MBDns>0+vtx<60", //14 0281 "HCALsingles+MBDns>0", //15 0282 "Jet6GeV+MBDns>0", //16 0283 "Jet8GeV+MBDns>0", //17 0284 "Jet10GeV+MBDns>0", //18 0285 "Jet12GeV+MBDns>0", //19 0286 "Jet6GeV", //20 0287 "Jet8GeV", //21 0288 "Jet10GeV", //22 0289 "Jet12GeV", //23 0290 "Photon2GeV+MBDns>0", //24 0291 "Photon3GeV+MBDns>0", //25 0292 "Photon4GeV+MBDns>0", //26 0293 "Photon5GeV+MBDns>0", //27 0294 "Photon2GeV", //28 0295 "Photon3GeV", //29 0296 "Photon4GeV", //30 0297 "Photon5GeV", //31 0298 "Jet6GeV+MBDns>0+vtx<10", //32 0299 "Jet8GeV+MBDns>0+vtx<10", //33 0300 "Jet10GeV+MBDns>0+vtx<10", //34 0301 "Jet12GeV+MBDns>0+vtx<10", //35 0302 "Photon3GeV+MBDns>0+vtx<10", //36 0303 "Photon4GeV+MBDns>0+vtx<10", //37 0304 "Photon5GeV+MBDns>0+vtx<10", //38 0305 "", //39 0306 "", //40 0307 "", //41 0308 "", //42 0309 "", //43 0310 "", //44 0311 "", //45 0312 "", //46 0313 "", //47 0314 "", //48 0315 "", //49 0316 "", //50 0317 "", //51 0318 "", //52 0319 "", //53 0320 "", //54 0321 "", //55 0322 "", //56 0323 "", //57 0324 "", //58 0325 "", //59 0326 "", //60 0327 "", //61 0328 "", //62 0329 "" }; //63 0330 0331 //----- END, rest older.... 0332 0333 // static const int NE = 11; 0334 // static const float roots[NE] = { 7.7 , 11.5, 14.5 , 19.6, 27, 39, 62.4, 200, 3.0, 200, 200 }; 0335 // static const char* energies[NE] = {"7.7", "11.5", "14.5", "19.6", "27", "39", "62.4", "200", "3.0", "200", "200" }; 0336 // static const char* estrings[NE] = {"007", "011", "015", "019", "027", "039", "062", "200", "003","20011","20014_83M" }; 0337 // static const int edsid[NE] = { 19 , 20 , 31 , 23 , 25 , 18 , 17 , 16, 48, 24, 32 }; 0338 // 0339 //static const char* npartfiles[NE] = {"007","011","019","019","027","039","062","200run11","3.0fxt","009"}; 0340 // 0341 // static const int NMODEL = 2; 0342 // static const char* modnames[NMODEL] = {"urqmd","pythia"}; 0343 // 0344 // static const int NCent = 17; 0345 // static const int NCentUse = 10; 0346 // static const int NPart = 8; 0347 // static const int NBIN = 2; 0348 // static const int NCUM = 9; 0349 // 0350 // static const char *particleids[NPart] = {"#pi^{+}", "#pi^{-}", 0351 // "K^{+}" , "K^{-}" , 0352 // "p" , "#bar{p}", 0353 // "e^{+}" , "e^{-}"}; 0354 // static const char* centnames17[NCent] = {"MB","75-80%","70-75%","65-70%","60-65%", 0355 // "55-60%","50-55%","45-50%","40-45%","35-40%", 0356 // "30-35%","25-30%","20-25%","15-20%","10-15%", 0357 // "5-10%","0-5%"}; 0358 // static const char* centnames[NCentUse] = {"MB","70-80%","60-70%","50-60%","40-50%", 0359 // "30-40%","20-30%","10-20%","5-10%","0-5%"}; 0360 // static const char* centstrings[NCentUse]= {"MB","7080","6070","5060","4050", 0361 // "3040","2030","1020","0510","0005"}; 0362 // static const char* centnamessim[12] = {"MB","100-90%","90-80%","70-80%","60-70%","50-60%","40-50%", 0363 // "30-40%","20-30%","10-20%","5-10%","0-5%"}; 0364 // // 0365 // static const char* centnamesSD0[NCentUse] = {"MB","70-80%","60-70%","50-60%","40-50%", 0366 // "30-40%","20-30%","10-20%","5-10%","0-5%"}; 0367 // static const char* centnamesSD1[NCentUse] = {"MB","30-35%","25-30%","20-25%","15-20%", 0368 // "10-15%","7.5-10%","5-7.5%","2.5-5%","0-2.5%"}; 0369 // static const char* centnamesSD2[NCentUse] = {"MB","10-12.5%","8.75-10%","7.5-8.75%","6.25-7.5%", 0370 // "5-6.25%","3.75-5%","2.5-3.75%","1.25-2.5%","0-1.25%"}; 0371 // static const char *particlenames[NPart] = {"#pi^{+}+#pi^{-}", "#pi^{+}-#pi^{-}", 0372 // "K^{+}+K^{-}" , "K^{+}-K^{-}" , 0373 // "p+#bar{p}" , "p-#bar{p}" }; 0374 // static const char* cumnames[NCUM] = {"C_{1}","C_{2}","C_{3}","C_{4}", 0375 // "R_{12}","R_{31}", 0376 // "R_{32}","R_{42}","R_{43}"}; 0377 0378
| [ Source navigation ] | [ Diff markup ] | [ Identifier search ] | [ general search ] |
|
This page was automatically generated by the 2.3.7 LXR engine. The LXR team |
|