00001
00011 #include "SimDataFormats/ValidationFormats/interface/PValidationFormats.h"
00012
00014
00016
00017 void PGlobalSimHit::putRawGenPart(int n)
00018 {
00019 nRawGenPart = n;
00020 return;
00021 }
00022
00023 void PGlobalSimHit::putG4Vtx( const std::vector<float> &x, const std::vector<float> &y,
00024 const std::vector<float> &z)
00025 {
00026 nG4Vtx = x.size();
00027 G4Vtx.resize(nG4Vtx);
00028 for (int i = 0; i < nG4Vtx; ++i) {
00029 G4Vtx[i].x = x[i];
00030 G4Vtx[i].y = y[i];
00031 G4Vtx[i].z = z[i];
00032 }
00033
00034 return;
00035 }
00036
00037 void PGlobalSimHit::putG4Trk(const std::vector<float> &pt, const std::vector<float> &e)
00038 {
00039 nG4Trk = pt.size();
00040 G4Trk.resize(nG4Trk);
00041 for (int i = 0; i < nG4Trk; ++i) {
00042 G4Trk[i].pt = pt[i];
00043 G4Trk[i].e = e[i];
00044 }
00045
00046 return;
00047 }
00048
00049 void PGlobalSimHit::putECalHits(const std::vector<float> &e, const std::vector<float> &tof,
00050 const std::vector<float> &phi,
00051 const std::vector<float> &eta)
00052 {
00053 nECalHits = e.size();
00054 ECalHits.resize(nECalHits);
00055 for (int i = 0; i < nECalHits; ++i) {
00056 ECalHits[i].e = e[i];
00057 ECalHits[i].tof = tof[i];
00058 ECalHits[i].phi = phi[i];
00059 ECalHits[i].eta = eta[i];
00060 }
00061
00062 return;
00063 }
00064
00065 void PGlobalSimHit::putPreShHits(const std::vector<float>& e, const std::vector<float>& tof,
00066 const std::vector<float>& phi,
00067 const std::vector<float>& eta)
00068 {
00069 nPreShHits = e.size();
00070 PreShHits.resize(nPreShHits);
00071 for (int i = 0; i < nPreShHits; ++i) {
00072 PreShHits[i].e = e[i];
00073 PreShHits[i].tof = tof[i];
00074 PreShHits[i].phi = phi[i];
00075 PreShHits[i].eta = eta[i];
00076 }
00077
00078 return;
00079 }
00080
00081 void PGlobalSimHit::putHCalHits(const std::vector<float>& e, const std::vector<float>& tof,
00082 const std::vector<float>& phi,
00083 const std::vector<float>& eta)
00084 {
00085 nHCalHits = e.size();
00086 HCalHits.resize(nHCalHits);
00087 for (int i = 0; i < nHCalHits; ++i) {
00088 HCalHits[i].e = e[i];
00089 HCalHits[i].tof = tof[i];
00090 HCalHits[i].phi = phi[i];
00091 HCalHits[i].eta = eta[i];
00092 }
00093
00094 return;
00095 }
00096
00097 void PGlobalSimHit::putPxlFwdHits(const std::vector<float>& tof,
00098 const std::vector<float>& z,
00099 const std::vector<float>& phi,
00100 const std::vector<float>& eta)
00101 {
00102 nPxlFwdHits = tof.size();
00103 PxlFwdHits.resize(nPxlFwdHits);
00104 for (int i = 0; i < nPxlFwdHits; ++i) {
00105 PxlFwdHits[i].tof = tof[i];
00106 PxlFwdHits[i].z = z[i];
00107 PxlFwdHits[i].phi = phi[i];
00108 PxlFwdHits[i].eta = eta[i];
00109 }
00110
00111 return;
00112 }
00113
00114 void PGlobalSimHit::putPxlBrlHits(const std::vector<float>& tof,
00115 const std::vector<float>& r,
00116 const std::vector<float>& phi,
00117 const std::vector<float>& eta)
00118 {
00119 nPxlBrlHits = tof.size();
00120 PxlBrlHits.resize(nPxlBrlHits);
00121 for (int i = 0; i < nPxlBrlHits; ++i) {
00122 PxlBrlHits[i].tof = tof[i];
00123 PxlBrlHits[i].r = r[i];
00124 PxlBrlHits[i].phi = phi[i];
00125 PxlBrlHits[i].eta = eta[i];
00126 }
00127
00128 return;
00129 }
00130
00131 void PGlobalSimHit::putSiFwdHits(const std::vector<float>& tof,
00132 const std::vector<float>& z,
00133 const std::vector<float>& phi,
00134 const std::vector<float>& eta)
00135 {
00136 nSiFwdHits = tof.size();
00137 SiFwdHits.resize(nSiFwdHits);
00138 for (int i = 0; i < nSiFwdHits; ++i) {
00139 SiFwdHits[i].tof = tof[i];
00140 SiFwdHits[i].z = z[i];
00141 SiFwdHits[i].phi = phi[i];
00142 SiFwdHits[i].eta = eta[i];
00143 }
00144
00145 return;
00146 }
00147
00148 void PGlobalSimHit::putSiBrlHits(const std::vector<float>& tof, const std::vector<float>& r,
00149 const std::vector<float>& phi,
00150 const std::vector<float>& eta)
00151 {
00152 nSiBrlHits = tof.size();
00153 SiBrlHits.resize(nSiBrlHits);
00154 for (int i = 0; i < nSiBrlHits; ++i) {
00155 SiBrlHits[i].tof = tof[i];
00156 SiBrlHits[i].r = r[i];
00157 SiBrlHits[i].phi = phi[i];
00158 SiBrlHits[i].eta = eta[i];
00159 }
00160
00161 return;
00162 }
00163
00164 void PGlobalSimHit::putMuonCscHits(const std::vector<float>& tof,
00165 const std::vector<float>& z,
00166 const std::vector<float>& phi,
00167 const std::vector<float>& eta)
00168 {
00169 nMuonCscHits = tof.size();
00170 MuonCscHits.resize(nMuonCscHits);
00171 for (int i = 0; i < nMuonCscHits; ++i) {
00172 MuonCscHits[i].tof = tof[i];
00173 MuonCscHits[i].z = z[i];
00174 MuonCscHits[i].phi = phi[i];
00175 MuonCscHits[i].eta = eta[i];
00176 }
00177
00178 return;
00179 }
00180
00181 void PGlobalSimHit::putMuonDtHits(const std::vector<float>& tof,
00182 const std::vector<float>& r,
00183 const std::vector<float>& phi,
00184 const std::vector<float>& eta)
00185 {
00186 nMuonDtHits = tof.size();
00187 MuonDtHits.resize(nMuonDtHits);
00188 for (int i = 0; i < nMuonDtHits; ++i) {
00189 MuonDtHits[i].tof = tof[i];
00190 MuonDtHits[i].r = r[i];
00191 MuonDtHits[i].phi = phi[i];
00192 MuonDtHits[i].eta = eta[i];
00193 }
00194
00195 return;
00196 }
00197
00198 void PGlobalSimHit::putMuonRpcFwdHits(const std::vector<float>& tof,
00199 const std::vector<float>& z,
00200 const std::vector<float>& phi,
00201 const std::vector<float>& eta)
00202 {
00203 nMuonRpcFwdHits = tof.size();
00204 MuonRpcFwdHits.resize(nMuonRpcFwdHits);
00205 for (int i = 0; i < nMuonRpcFwdHits; ++i) {
00206 MuonRpcFwdHits[i].tof = tof[i];
00207 MuonRpcFwdHits[i].z = z[i];
00208 MuonRpcFwdHits[i].phi = phi[i];
00209 MuonRpcFwdHits[i].eta = eta[i];
00210 }
00211
00212 return;
00213 }
00214
00215 void PGlobalSimHit::putMuonRpcBrlHits(const std::vector<float>& tof,
00216 const std::vector<float>& r,
00217 const std::vector<float>& phi,
00218 const std::vector<float>& eta)
00219 {
00220 nMuonRpcBrlHits = tof.size();
00221 MuonRpcBrlHits.resize(nMuonRpcBrlHits);
00222 for (int i = 0; i < nMuonRpcBrlHits; ++i) {
00223 MuonRpcBrlHits[i].tof = tof[i];
00224 MuonRpcBrlHits[i].r = r[i];
00225 MuonRpcBrlHits[i].phi = phi[i];
00226 MuonRpcBrlHits[i].eta = eta[i];
00227 }
00228
00229 return;
00230 }
00231
00233
00235
00236 void PGlobalDigi::putEBCalDigis(const std::vector<int>& maxpos,
00237 const std::vector<double>& aee,
00238 const std::vector<float>& she)
00239 {
00240 nEBCalDigis = maxpos.size();
00241 EBCalDigis.resize(nEBCalDigis);
00242 for (int i = 0; i < nEBCalDigis; ++i) {
00243 EBCalDigis[i].maxPos = maxpos[i];
00244 EBCalDigis[i].AEE = aee[i];
00245 EBCalDigis[i].SHE = she[i];
00246 }
00247
00248 return;
00249 }
00250
00251 void PGlobalDigi::putEECalDigis(const std::vector<int>& maxpos,
00252 const std::vector<double>& aee,
00253 const std::vector<float>& she)
00254 {
00255 nEECalDigis = maxpos.size();
00256 EECalDigis.resize(nEECalDigis);
00257 for (int i = 0; i < nEECalDigis; ++i) {
00258 EECalDigis[i].maxPos = maxpos[i];
00259 EECalDigis[i].AEE = aee[i];
00260 EECalDigis[i].SHE = she[i];
00261 }
00262
00263 return;
00264 }
00265
00266 void PGlobalDigi::putESCalDigis(const std::vector<float>& adc0,
00267 const std::vector<float>& adc1,
00268 const std::vector<float>& adc2,
00269 const std::vector<float>& she)
00270 {
00271 nESCalDigis = adc0.size();
00272 ESCalDigis.resize(nESCalDigis);
00273 for (int i = 0; i < nESCalDigis; ++i) {
00274 ESCalDigis[i].ADC0 = adc0[i];
00275 ESCalDigis[i].ADC1 = adc1[i];
00276 ESCalDigis[i].ADC2 = adc2[i];
00277 ESCalDigis[i].SHE = she[i];
00278 }
00279
00280 return;
00281 }
00282
00283 void PGlobalDigi::putHBCalDigis(const std::vector<float>& aee,
00284 const std::vector<float>& she)
00285 {
00286 nHBCalDigis = aee.size();
00287 HBCalDigis.resize(nHBCalDigis);
00288 for (int i = 0; i < nHBCalDigis; ++i) {
00289 HBCalDigis[i].AEE = aee[i];
00290 HBCalDigis[i].SHE = she[i];
00291 }
00292
00293 return;
00294 }
00295
00296 void PGlobalDigi::putHECalDigis(const std::vector<float>& aee,
00297 const std::vector<float>& she)
00298 {
00299 nHECalDigis = aee.size();
00300 HECalDigis.resize(nHECalDigis);
00301 for (int i = 0; i < nHECalDigis; ++i) {
00302 HECalDigis[i].AEE = aee[i];
00303 HECalDigis[i].SHE = she[i];
00304 }
00305
00306 return;
00307 }
00308
00309 void PGlobalDigi::putHOCalDigis(const std::vector<float>& aee,
00310 const std::vector<float>& she)
00311 {
00312 nHOCalDigis = aee.size();
00313 HOCalDigis.resize(nHOCalDigis);
00314 for (int i = 0; i < nHOCalDigis; ++i) {
00315 HOCalDigis[i].AEE = aee[i];
00316 HOCalDigis[i].SHE = she[i];
00317 }
00318
00319 return;
00320 }
00321
00322 void PGlobalDigi::putHFCalDigis(const std::vector<float>& aee,
00323 const std::vector<float>& she)
00324 {
00325 nHFCalDigis = aee.size();
00326 HFCalDigis.resize(nHFCalDigis);
00327 for (int i = 0; i < nHFCalDigis; ++i) {
00328 HFCalDigis[i].AEE = aee[i];
00329 HFCalDigis[i].SHE = she[i];
00330 }
00331
00332 return;
00333 }
00334
00335 void PGlobalDigi::putTIBL1Digis(const std::vector<float>& adc,
00336 const std::vector<int>& strip)
00337 {
00338 nTIBL1Digis = adc.size();
00339 TIBL1Digis.resize(nTIBL1Digis);
00340 for (int i = 0; i < nTIBL1Digis; ++i) {
00341 TIBL1Digis[i].ADC = adc[i];
00342 TIBL1Digis[i].STRIP = strip[i];
00343 }
00344
00345 return;
00346 }
00347
00348 void PGlobalDigi::putTIBL2Digis(const std::vector<float>& adc,
00349 const std::vector<int>& strip)
00350 {
00351 nTIBL2Digis = adc.size();
00352 TIBL2Digis.resize(nTIBL2Digis);
00353 for (int i = 0; i < nTIBL2Digis; ++i) {
00354 TIBL2Digis[i].ADC = adc[i];
00355 TIBL2Digis[i].STRIP = strip[i];
00356 }
00357
00358 return;
00359 }
00360
00361 void PGlobalDigi::putTIBL3Digis(const std::vector<float>& adc,
00362 const std::vector<int>& strip)
00363 {
00364 nTIBL3Digis = adc.size();
00365 TIBL3Digis.resize(nTIBL3Digis);
00366 for (int i = 0; i < nTIBL3Digis; ++i) {
00367 TIBL3Digis[i].ADC = adc[i];
00368 TIBL3Digis[i].STRIP = strip[i];
00369 }
00370
00371 return;
00372 }
00373
00374 void PGlobalDigi::putTIBL4Digis(const std::vector<float>& adc,
00375 const std::vector<int>& strip)
00376 {
00377 nTIBL4Digis = adc.size();
00378 TIBL4Digis.resize(nTIBL4Digis);
00379 for (int i = 0; i < nTIBL4Digis; ++i) {
00380 TIBL4Digis[i].ADC = adc[i];
00381 TIBL4Digis[i].STRIP = strip[i];
00382 }
00383
00384 return;
00385 }
00386
00387 void PGlobalDigi::putTOBL1Digis(const std::vector<float>& adc,
00388 const std::vector<int>& strip)
00389 {
00390 nTOBL1Digis = adc.size();
00391 TOBL1Digis.resize(nTOBL1Digis);
00392 for (int i = 0; i < nTOBL1Digis; ++i) {
00393 TOBL1Digis[i].ADC = adc[i];
00394 TOBL1Digis[i].STRIP = strip[i];
00395 }
00396
00397 return;
00398 }
00399
00400 void PGlobalDigi::putTOBL2Digis(const std::vector<float>& adc,
00401 const std::vector<int>& strip)
00402 {
00403 nTOBL2Digis = adc.size();
00404 TOBL2Digis.resize(nTOBL2Digis);
00405 for (int i = 0; i < nTOBL2Digis; ++i) {
00406 TOBL2Digis[i].ADC = adc[i];
00407 TOBL2Digis[i].STRIP = strip[i];
00408 }
00409
00410 return;
00411 }
00412
00413 void PGlobalDigi::putTOBL3Digis(const std::vector<float>& adc,
00414 const std::vector<int>& strip)
00415 {
00416 nTOBL3Digis = adc.size();
00417 TOBL3Digis.resize(nTOBL3Digis);
00418 for (int i = 0; i < nTOBL3Digis; ++i) {
00419 TOBL3Digis[i].ADC = adc[i];
00420 TOBL3Digis[i].STRIP = strip[i];
00421 }
00422
00423 return;
00424 }
00425
00426 void PGlobalDigi::putTOBL4Digis(const std::vector<float>& adc,
00427 const std::vector<int>& strip)
00428 {
00429 nTOBL4Digis = adc.size();
00430 TOBL4Digis.resize(nTOBL4Digis);
00431 for (int i = 0; i < nTOBL4Digis; ++i) {
00432 TOBL4Digis[i].ADC = adc[i];
00433 TOBL4Digis[i].STRIP = strip[i];
00434 }
00435
00436 return;
00437 }
00438
00439 void PGlobalDigi::putTIDW1Digis(const std::vector<float>& adc,
00440 const std::vector<int>& strip)
00441 {
00442 nTIDW1Digis = adc.size();
00443 TIDW1Digis.resize(nTIDW1Digis);
00444 for (int i = 0; i < nTIDW1Digis; ++i) {
00445 TIDW1Digis[i].ADC = adc[i];
00446 TIDW1Digis[i].STRIP = strip[i];
00447 }
00448
00449 return;
00450 }
00451
00452 void PGlobalDigi::putTIDW2Digis(const std::vector<float>& adc,
00453 const std::vector<int>& strip)
00454 {
00455 nTIDW2Digis = adc.size();
00456 TIDW2Digis.resize(nTIDW2Digis);
00457 for (int i = 0; i < nTIDW2Digis; ++i) {
00458 TIDW2Digis[i].ADC = adc[i];
00459 TIDW2Digis[i].STRIP = strip[i];
00460 }
00461
00462 return;
00463 }
00464
00465 void PGlobalDigi::putTIDW3Digis(const std::vector<float>& adc,
00466 const std::vector<int>& strip)
00467 {
00468 nTIDW3Digis = adc.size();
00469 TIDW3Digis.resize(nTIDW3Digis);
00470 for (int i = 0; i < nTIDW3Digis; ++i) {
00471 TIDW3Digis[i].ADC = adc[i];
00472 TIDW3Digis[i].STRIP = strip[i];
00473 }
00474
00475 return;
00476 }
00477
00478 void PGlobalDigi::putTECW1Digis(const std::vector<float>& adc,
00479 const std::vector<int>& strip)
00480 {
00481 nTECW1Digis = adc.size();
00482 TECW1Digis.resize(nTECW1Digis);
00483 for (int i = 0; i < nTECW1Digis; ++i) {
00484 TECW1Digis[i].ADC = adc[i];
00485 TECW1Digis[i].STRIP = strip[i];
00486 }
00487
00488 return;
00489 }
00490
00491 void PGlobalDigi::putTECW2Digis(const std::vector<float>& adc,
00492 const std::vector<int>& strip)
00493 {
00494 nTECW2Digis = adc.size();
00495 TECW2Digis.resize(nTECW2Digis);
00496 for (int i = 0; i < nTECW2Digis; ++i) {
00497 TECW2Digis[i].ADC = adc[i];
00498 TECW2Digis[i].STRIP = strip[i];
00499 }
00500
00501 return;
00502 }
00503
00504 void PGlobalDigi::putTECW3Digis(const std::vector<float>& adc,
00505 const std::vector<int>& strip)
00506 {
00507 nTECW3Digis = adc.size();
00508 TECW3Digis.resize(nTECW3Digis);
00509 for (int i = 0; i < nTECW3Digis; ++i) {
00510 TECW3Digis[i].ADC = adc[i];
00511 TECW3Digis[i].STRIP = strip[i];
00512 }
00513
00514 return;
00515 }
00516
00517 void PGlobalDigi::putTECW4Digis(const std::vector<float>& adc,
00518 const std::vector<int>& strip)
00519 {
00520 nTECW4Digis = adc.size();
00521 TECW4Digis.resize(nTECW4Digis);
00522 for (int i = 0; i < nTECW4Digis; ++i) {
00523 TECW4Digis[i].ADC = adc[i];
00524 TECW4Digis[i].STRIP = strip[i];
00525 }
00526
00527 return;
00528 }
00529
00530 void PGlobalDigi::putTECW5Digis(const std::vector<float>& adc,
00531 const std::vector<int>& strip)
00532 {
00533 nTECW5Digis = adc.size();
00534 TECW5Digis.resize(nTECW5Digis);
00535 for (int i = 0; i < nTECW5Digis; ++i) {
00536 TECW5Digis[i].ADC = adc[i];
00537 TECW5Digis[i].STRIP = strip[i];
00538 }
00539
00540 return;
00541 }
00542
00543 void PGlobalDigi::putTECW6Digis(const std::vector<float>& adc,
00544 const std::vector<int>& strip)
00545 {
00546 nTECW6Digis = adc.size();
00547 TECW6Digis.resize(nTECW6Digis);
00548 for (int i = 0; i < nTECW6Digis; ++i) {
00549 TECW6Digis[i].ADC = adc[i];
00550 TECW6Digis[i].STRIP = strip[i];
00551 }
00552
00553 return;
00554 }
00555
00556 void PGlobalDigi::putTECW7Digis(const std::vector<float>& adc,
00557 const std::vector<int>& strip)
00558 {
00559 nTECW7Digis = adc.size();
00560 TECW7Digis.resize(nTECW7Digis);
00561 for (int i = 0; i < nTECW7Digis; ++i) {
00562 TECW7Digis[i].ADC = adc[i];
00563 TECW7Digis[i].STRIP = strip[i];
00564 }
00565
00566 return;
00567 }
00568
00569 void PGlobalDigi::putTECW8Digis(const std::vector<float>& adc,
00570 const std::vector<int>& strip)
00571 {
00572 nTECW8Digis = adc.size();
00573 TECW8Digis.resize(nTECW8Digis);
00574 for (int i = 0; i < nTECW8Digis; ++i) {
00575 TECW8Digis[i].ADC = adc[i];
00576 TECW8Digis[i].STRIP = strip[i];
00577 }
00578
00579 return;
00580 }
00581
00582 void PGlobalDigi::putBRL1Digis(const std::vector<float>& adc,
00583 const std::vector<int>& row,
00584 const std::vector<int>& column)
00585 {
00586 nBRL1Digis = adc.size();
00587 BRL1Digis.resize(nBRL1Digis);
00588 for (int i = 0; i < nBRL1Digis; ++i) {
00589 BRL1Digis[i].ADC = adc[i];
00590 BRL1Digis[i].ROW = row[i];
00591 BRL1Digis[i].COLUMN = column[i];
00592 }
00593
00594 return;
00595 }
00596
00597 void PGlobalDigi::putBRL2Digis(const std::vector<float>& adc,
00598 const std::vector<int>& row,
00599 const std::vector<int>& column)
00600 {
00601 nBRL2Digis = adc.size();
00602 BRL2Digis.resize(nBRL2Digis);
00603 for (int i = 0; i < nBRL2Digis; ++i) {
00604 BRL2Digis[i].ADC = adc[i];
00605 BRL2Digis[i].ROW = row[i];
00606 BRL2Digis[i].COLUMN = column[i];
00607 }
00608
00609 return;
00610 }
00611
00612 void PGlobalDigi::putBRL3Digis(const std::vector<float>& adc,
00613 const std::vector<int>& row,
00614 const std::vector<int>& column)
00615 {
00616 nBRL3Digis = adc.size();
00617 BRL3Digis.resize(nBRL3Digis);
00618 for (int i = 0; i < nBRL3Digis; ++i) {
00619 BRL3Digis[i].ADC = adc[i];
00620 BRL3Digis[i].ROW = row[i];
00621 BRL3Digis[i].COLUMN = column[i];
00622 }
00623
00624 return;
00625 }
00626
00627 void PGlobalDigi::putFWD1pDigis(const std::vector<float>& adc,
00628 const std::vector<int>& row,
00629 const std::vector<int>& column)
00630 {
00631 nFWD1pDigis = adc.size();
00632 FWD1pDigis.resize(nFWD1pDigis);
00633 for (int i = 0; i < nFWD1pDigis; ++i) {
00634 FWD1pDigis[i].ADC = adc[i];
00635 FWD1pDigis[i].ROW = row[i];
00636 FWD1pDigis[i].COLUMN = column[i];
00637 }
00638
00639 return;
00640 }
00641
00642 void PGlobalDigi::putFWD1nDigis(const std::vector<float>& adc,
00643 const std::vector<int>& row,
00644 const std::vector<int>& column)
00645 {
00646 nFWD1nDigis = adc.size();
00647 FWD1nDigis.resize(nFWD1nDigis);
00648 for (int i = 0; i < nFWD1nDigis; ++i) {
00649 FWD1nDigis[i].ADC = adc[i];
00650 FWD1nDigis[i].ROW = row[i];
00651 FWD1nDigis[i].COLUMN = column[i];
00652 }
00653
00654 return;
00655 }
00656
00657 void PGlobalDigi::putFWD2pDigis(const std::vector<float>& adc,
00658 const std::vector<int>& row,
00659 const std::vector<int>& column)
00660 {
00661 nFWD2pDigis = adc.size();
00662 FWD2pDigis.resize(nFWD2pDigis);
00663 for (int i = 0; i < nFWD2pDigis; ++i) {
00664 FWD2pDigis[i].ADC = adc[i];
00665 FWD2pDigis[i].ROW = row[i];
00666 FWD2pDigis[i].COLUMN = column[i];
00667 }
00668
00669 return;
00670 }
00671
00672 void PGlobalDigi::putFWD2nDigis(const std::vector<float>& adc,
00673 const std::vector<int>& row,
00674 const std::vector<int>& column)
00675 {
00676 nFWD2nDigis = adc.size();
00677 FWD2nDigis.resize(nFWD2nDigis);
00678 for (int i = 0; i < nFWD2nDigis; ++i) {
00679 FWD2nDigis[i].ADC = adc[i];
00680 FWD2nDigis[i].ROW = row[i];
00681 FWD2nDigis[i].COLUMN = column[i];
00682 }
00683
00684 return;
00685 }
00686
00687 void PGlobalDigi::putMB1Digis(const std::vector<int>& slayer,
00688 const std::vector<float>& time,
00689 const std::vector<int>& layer)
00690 {
00691 nMB1Digis = slayer.size();
00692 MB1Digis.resize(nMB1Digis);
00693 for (int i = 0; i < nMB1Digis; ++i) {
00694 MB1Digis[i].SLAYER = slayer[i];
00695 MB1Digis[i].TIME = time[i];
00696 MB1Digis[i].LAYER = layer[i];
00697 }
00698
00699 return;
00700 }
00701
00702 void PGlobalDigi::putMB2Digis(const std::vector<int>& slayer,
00703 const std::vector<float>& time,
00704 const std::vector<int>& layer)
00705 {
00706 nMB2Digis = slayer.size();
00707 MB2Digis.resize(nMB2Digis);
00708 for (int i = 0; i < nMB2Digis; ++i) {
00709 MB2Digis[i].SLAYER = slayer[i];
00710 MB2Digis[i].TIME = time[i];
00711 MB2Digis[i].LAYER = layer[i];
00712 }
00713
00714 return;
00715 }
00716
00717 void PGlobalDigi::putMB3Digis(const std::vector<int>& slayer,
00718 const std::vector<float>& time,
00719 const std::vector<int>& layer)
00720 {
00721 nMB3Digis = slayer.size();
00722 MB3Digis.resize(nMB3Digis);
00723 for (int i = 0; i < nMB3Digis; ++i) {
00724 MB3Digis[i].SLAYER = slayer[i];
00725 MB3Digis[i].TIME = time[i];
00726 MB3Digis[i].LAYER = layer[i];
00727 }
00728
00729 return;
00730 }
00731
00732 void PGlobalDigi::putMB4Digis(const std::vector<int>& slayer,
00733 const std::vector<float>& time,
00734 const std::vector<int>& layer)
00735 {
00736 nMB4Digis = slayer.size();
00737 MB4Digis.resize(nMB4Digis);
00738 for (int i = 0; i < nMB4Digis; ++i) {
00739 MB4Digis[i].SLAYER = slayer[i];
00740 MB4Digis[i].TIME = time[i];
00741 MB4Digis[i].LAYER = layer[i];
00742 }
00743
00744 return;
00745 }
00746
00747 void PGlobalDigi::putCSCstripDigis(const std::vector<float>& adc)
00748 {
00749 nCSCstripDigis = adc.size();
00750 CSCstripDigis.resize(nCSCstripDigis);
00751 for (int i = 0; i < nCSCstripDigis; ++i) {
00752 CSCstripDigis[i].ADC = adc[i];
00753 }
00754
00755 return;
00756 }
00757
00758 void PGlobalDigi::putCSCwireDigis(const std::vector<float>& time)
00759 {
00760 nCSCwireDigis = time.size();
00761 CSCwireDigis.resize(nCSCwireDigis);
00762 for (int i = 0; i < nCSCwireDigis; ++i) {
00763 CSCwireDigis[i].TIME = time[i];
00764 }
00765
00766 return;
00767 }
00768
00770
00772
00773 void PGlobalRecHit::putEBCalRecHits(const std::vector<float>& re,
00774 const std::vector<float>& she)
00775 {
00776 nEBCalRecHits = re.size();
00777 EBCalRecHits.resize(nEBCalRecHits);
00778 for (int i = 0; i < nEBCalRecHits; ++i) {
00779 EBCalRecHits[i].RE = re[i];
00780 EBCalRecHits[i].SHE = she[i];
00781 }
00782
00783 return;
00784 }
00785
00786 void PGlobalRecHit::putEECalRecHits(const std::vector<float>& re,
00787 const std::vector<float>& she)
00788 {
00789 nEECalRecHits = re.size();
00790 EECalRecHits.resize(nEECalRecHits);
00791 for (int i = 0; i < nEECalRecHits; ++i) {
00792 EECalRecHits[i].RE = re[i];
00793 EECalRecHits[i].SHE = she[i];
00794 }
00795
00796 return;
00797 }
00798
00799 void PGlobalRecHit::putESCalRecHits(const std::vector<float>& re,
00800 const std::vector<float>& she)
00801 {
00802 nESCalRecHits = re.size();
00803 ESCalRecHits.resize(nESCalRecHits);
00804 for (int i = 0; i < nESCalRecHits; ++i) {
00805 ESCalRecHits[i].RE = re[i];
00806 ESCalRecHits[i].SHE = she[i];
00807 }
00808
00809 return;
00810 }
00811
00812 void PGlobalRecHit::putHBCalRecHits(const std::vector<float>& rec,
00813 const std::vector<float>& r,
00814 const std::vector<float>& she)
00815 {
00816 nHBCalRecHits = rec.size();
00817 HBCalRecHits.resize(nHBCalRecHits);
00818 for (int i = 0; i < nHBCalRecHits; ++i) {
00819 HBCalRecHits[i].REC = rec[i];
00820 HBCalRecHits[i].R = r[i];
00821 HBCalRecHits[i].SHE = she[i];
00822 }
00823
00824 return;
00825 }
00826
00827 void PGlobalRecHit::putHECalRecHits(const std::vector<float>& rec,
00828 const std::vector<float>& r,
00829 const std::vector<float>& she)
00830 {
00831 nHECalRecHits = rec.size();
00832 HECalRecHits.resize(nHECalRecHits);
00833 for (int i = 0; i < nHECalRecHits; ++i) {
00834 HECalRecHits[i].REC = rec[i];
00835 HECalRecHits[i].R = r[i];
00836 HECalRecHits[i].SHE = she[i];
00837 }
00838
00839 return;
00840 }
00841
00842 void PGlobalRecHit::putHOCalRecHits(const std::vector<float>& rec,
00843 const std::vector<float>& r,
00844 const std::vector<float>& she)
00845 {
00846 nHOCalRecHits = rec.size();
00847 HOCalRecHits.resize(nHOCalRecHits);
00848 for (int i = 0; i < nHOCalRecHits; ++i) {
00849 HOCalRecHits[i].REC = rec[i];
00850 HOCalRecHits[i].R = r[i];
00851 HOCalRecHits[i].SHE = she[i];
00852 }
00853
00854 return;
00855 }
00856
00857 void PGlobalRecHit::putHFCalRecHits(const std::vector<float>& rec,
00858 const std::vector<float>& r,
00859 const std::vector<float>& she)
00860 {
00861 nHFCalRecHits = rec.size();
00862 HFCalRecHits.resize(nHFCalRecHits);
00863 for (int i = 0; i < nHFCalRecHits; ++i) {
00864 HFCalRecHits[i].REC = rec[i];
00865 HFCalRecHits[i].R = r[i];
00866 HFCalRecHits[i].SHE = she[i];
00867 }
00868
00869 return;
00870 }
00871
00872 void PGlobalRecHit::putTIBL1RecHits(const std::vector<float>& rx,
00873 const std::vector<float>& ry,
00874 const std::vector<float>& sx,
00875 const std::vector<float>& sy)
00876 {
00877 nTIBL1RecHits = rx.size();
00878 TIBL1RecHits.resize(nTIBL1RecHits);
00879 for (int i = 0; i < nTIBL1RecHits; ++i) {
00880 TIBL1RecHits[i].RX = rx[i];
00881 TIBL1RecHits[i].RY = ry[i];
00882 TIBL1RecHits[i].SX = sx[i];
00883 TIBL1RecHits[i].SY = sy[i];
00884 }
00885
00886 return;
00887 }
00888
00889 void PGlobalRecHit::putTIBL2RecHits(const std::vector<float>& rx,
00890 const std::vector<float>& ry,
00891 const std::vector<float>& sx,
00892 const std::vector<float>& sy)
00893 {
00894 nTIBL2RecHits = rx.size();
00895 TIBL2RecHits.resize(nTIBL2RecHits);
00896 for (int i = 0; i < nTIBL2RecHits; ++i) {
00897 TIBL2RecHits[i].RX = rx[i];
00898 TIBL2RecHits[i].RY = ry[i];
00899 TIBL2RecHits[i].SX = sx[i];
00900 TIBL2RecHits[i].SY = sy[i];
00901 }
00902
00903 return;
00904 }
00905
00906 void PGlobalRecHit::putTIBL3RecHits(const std::vector<float>& rx,
00907 const std::vector<float>& ry,
00908 const std::vector<float>& sx,
00909 const std::vector<float>& sy)
00910 {
00911 nTIBL3RecHits = rx.size();
00912 TIBL3RecHits.resize(nTIBL3RecHits);
00913 for (int i = 0; i < nTIBL3RecHits; ++i) {
00914 TIBL3RecHits[i].RX = rx[i];
00915 TIBL3RecHits[i].RY = ry[i];
00916 TIBL3RecHits[i].SX = sx[i];
00917 TIBL3RecHits[i].SY = sy[i];
00918 }
00919
00920 return;
00921 }
00922
00923 void PGlobalRecHit::putTIBL4RecHits(const std::vector<float>& rx,
00924 const std::vector<float>& ry,
00925 const std::vector<float>& sx,
00926 const std::vector<float>& sy)
00927 {
00928 nTIBL4RecHits = rx.size();
00929 TIBL4RecHits.resize(nTIBL4RecHits);
00930 for (int i = 0; i < nTIBL4RecHits; ++i) {
00931 TIBL4RecHits[i].RX = rx[i];
00932 TIBL4RecHits[i].RY = ry[i];
00933 TIBL4RecHits[i].SX = sx[i];
00934 TIBL4RecHits[i].SY = sy[i];
00935 }
00936
00937 return;
00938 }
00939
00940 void PGlobalRecHit::putTOBL1RecHits(const std::vector<float>& rx,
00941 const std::vector<float>& ry,
00942 const std::vector<float>& sx,
00943 const std::vector<float>& sy)
00944 {
00945 nTOBL1RecHits = rx.size();
00946 TOBL1RecHits.resize(nTOBL1RecHits);
00947 for (int i = 0; i < nTOBL1RecHits; ++i) {
00948 TOBL1RecHits[i].RX = rx[i];
00949 TOBL1RecHits[i].RY = ry[i];
00950 TOBL1RecHits[i].SX = sx[i];
00951 TOBL1RecHits[i].SY = sy[i];
00952 }
00953
00954 return;
00955 }
00956
00957 void PGlobalRecHit::putTOBL2RecHits(const std::vector<float>& rx,
00958 const std::vector<float>& ry,
00959 const std::vector<float>& sx,
00960 const std::vector<float>& sy)
00961 {
00962 nTOBL2RecHits = rx.size();
00963 TOBL2RecHits.resize(nTOBL2RecHits);
00964 for (int i = 0; i < nTOBL2RecHits; ++i) {
00965 TOBL2RecHits[i].RX = rx[i];
00966 TOBL2RecHits[i].RY = ry[i];
00967 TOBL2RecHits[i].SX = sx[i];
00968 TOBL2RecHits[i].SY = sy[i];
00969 }
00970
00971 return;
00972 }
00973
00974 void PGlobalRecHit::putTOBL3RecHits(const std::vector<float>& rx,
00975 const std::vector<float>& ry,
00976 const std::vector<float>& sx,
00977 const std::vector<float>& sy)
00978 {
00979 nTOBL3RecHits = rx.size();
00980 TOBL3RecHits.resize(nTOBL3RecHits);
00981 for (int i = 0; i < nTOBL3RecHits; ++i) {
00982 TOBL3RecHits[i].RX = rx[i];
00983 TOBL3RecHits[i].RY = ry[i];
00984 TOBL3RecHits[i].SX = sx[i];
00985 TOBL3RecHits[i].SY = sy[i];
00986 }
00987
00988 return;
00989 }
00990
00991 void PGlobalRecHit::putTOBL4RecHits(const std::vector<float>& rx,
00992 const std::vector<float>& ry,
00993 const std::vector<float>& sx,
00994 const std::vector<float>& sy)
00995 {
00996 nTOBL4RecHits = rx.size();
00997 TOBL4RecHits.resize(nTOBL4RecHits);
00998 for (int i = 0; i < nTOBL4RecHits; ++i) {
00999 TOBL4RecHits[i].RX = rx[i];
01000 TOBL4RecHits[i].RY = ry[i];
01001 TOBL4RecHits[i].SX = sx[i];
01002 TOBL4RecHits[i].SY = sy[i];
01003 }
01004
01005 return;
01006 }
01007
01008 void PGlobalRecHit::putTIDW1RecHits(const std::vector<float>& rx,
01009 const std::vector<float>& ry,
01010 const std::vector<float>& sx,
01011 const std::vector<float>& sy)
01012 {
01013 nTIDW1RecHits = rx.size();
01014 TIDW1RecHits.resize(nTIDW1RecHits);
01015 for (int i = 0; i < nTIDW1RecHits; ++i) {
01016 TIDW1RecHits[i].RX = rx[i];
01017 TIDW1RecHits[i].RY = ry[i];
01018 TIDW1RecHits[i].SX = sx[i];
01019 TIDW1RecHits[i].SY = sy[i];
01020 }
01021
01022 return;
01023 }
01024
01025 void PGlobalRecHit::putTIDW2RecHits(const std::vector<float>& rx,
01026 const std::vector<float>& ry,
01027 const std::vector<float>& sx,
01028 const std::vector<float>& sy)
01029 {
01030 nTIDW2RecHits = rx.size();
01031 TIDW2RecHits.resize(nTIDW2RecHits);
01032 for (int i = 0; i < nTIDW2RecHits; ++i) {
01033 TIDW2RecHits[i].RX = rx[i];
01034 TIDW2RecHits[i].RY = ry[i];
01035 TIDW2RecHits[i].SX = sx[i];
01036 TIDW2RecHits[i].SY = sy[i];
01037 }
01038
01039 return;
01040 }
01041
01042 void PGlobalRecHit::putTIDW3RecHits(const std::vector<float>& rx,
01043 const std::vector<float>& ry,
01044 const std::vector<float>& sx,
01045 const std::vector<float>& sy)
01046 {
01047 nTIDW3RecHits = rx.size();
01048 TIDW3RecHits.resize(nTIDW3RecHits);
01049 for (int i = 0; i < nTIDW3RecHits; ++i) {
01050 TIDW3RecHits[i].RX = rx[i];
01051 TIDW3RecHits[i].RY = ry[i];
01052 TIDW3RecHits[i].SX = sx[i];
01053 TIDW3RecHits[i].SY = sy[i];
01054 }
01055
01056 return;
01057 }
01058
01059 void PGlobalRecHit::putTECW1RecHits(const std::vector<float>& rx,
01060 const std::vector<float>& ry,
01061 const std::vector<float>& sx,
01062 const std::vector<float>& sy)
01063 {
01064 nTECW1RecHits = rx.size();
01065 TECW1RecHits.resize(nTECW1RecHits);
01066 for (int i = 0; i < nTECW1RecHits; ++i) {
01067 TECW1RecHits[i].RX = rx[i];
01068 TECW1RecHits[i].RY = ry[i];
01069 TECW1RecHits[i].SX = sx[i];
01070 TECW1RecHits[i].SY = sy[i];
01071 }
01072
01073 return;
01074 }
01075
01076 void PGlobalRecHit::putTECW2RecHits(const std::vector<float>& rx,
01077 const std::vector<float>& ry,
01078 const std::vector<float>& sx,
01079 const std::vector<float>& sy)
01080 {
01081 nTECW2RecHits = rx.size();
01082 TECW2RecHits.resize(nTECW2RecHits);
01083 for (int i = 0; i < nTECW2RecHits; ++i) {
01084 TECW2RecHits[i].RX = rx[i];
01085 TECW2RecHits[i].RY = ry[i];
01086 TECW2RecHits[i].SX = sx[i];
01087 TECW2RecHits[i].SY = sy[i];
01088 }
01089
01090 return;
01091 }
01092
01093 void PGlobalRecHit::putTECW3RecHits(const std::vector<float>& rx,
01094 const std::vector<float>& ry,
01095 const std::vector<float>& sx,
01096 const std::vector<float>& sy)
01097 {
01098 nTECW3RecHits = rx.size();
01099 TECW3RecHits.resize(nTECW3RecHits);
01100 for (int i = 0; i < nTECW3RecHits; ++i) {
01101 TECW3RecHits[i].RX = rx[i];
01102 TECW3RecHits[i].RY = ry[i];
01103 TECW3RecHits[i].SX = sx[i];
01104 TECW3RecHits[i].SY = sy[i];
01105 }
01106
01107 return;
01108 }
01109
01110 void PGlobalRecHit::putTECW4RecHits(const std::vector<float>& rx,
01111 const std::vector<float>& ry,
01112 const std::vector<float>& sx,
01113 const std::vector<float>& sy)
01114 {
01115 nTECW4RecHits = rx.size();
01116 TECW4RecHits.resize(nTECW4RecHits);
01117 for (int i = 0; i < nTECW4RecHits; ++i) {
01118 TECW4RecHits[i].RX = rx[i];
01119 TECW4RecHits[i].RY = ry[i];
01120 TECW4RecHits[i].SX = sx[i];
01121 TECW4RecHits[i].SY = sy[i];
01122 }
01123
01124 return;
01125 }
01126
01127 void PGlobalRecHit::putTECW5RecHits(const std::vector<float>& rx,
01128 const std::vector<float>& ry,
01129 const std::vector<float>& sx,
01130 const std::vector<float>& sy)
01131 {
01132 nTECW5RecHits = rx.size();
01133 TECW5RecHits.resize(nTECW5RecHits);
01134 for (int i = 0; i < nTECW5RecHits; ++i) {
01135 TECW5RecHits[i].RX = rx[i];
01136 TECW5RecHits[i].RY = ry[i];
01137 TECW5RecHits[i].SX = sx[i];
01138 TECW5RecHits[i].SY = sy[i];
01139 }
01140
01141 return;
01142 }
01143
01144 void PGlobalRecHit::putTECW6RecHits(const std::vector<float>& rx,
01145 const std::vector<float>& ry,
01146 const std::vector<float>& sx,
01147 const std::vector<float>& sy)
01148 {
01149 nTECW6RecHits = rx.size();
01150 TECW6RecHits.resize(nTECW6RecHits);
01151 for (int i = 0; i < nTECW6RecHits; ++i) {
01152 TECW6RecHits[i].RX = rx[i];
01153 TECW6RecHits[i].RY = ry[i];
01154 TECW6RecHits[i].SX = sx[i];
01155 TECW6RecHits[i].SY = sy[i];
01156 }
01157
01158 return;
01159 }
01160
01161 void PGlobalRecHit::putTECW7RecHits(const std::vector<float>& rx,
01162 const std::vector<float>& ry,
01163 const std::vector<float>& sx,
01164 const std::vector<float>& sy)
01165 {
01166 nTECW7RecHits = rx.size();
01167 TECW7RecHits.resize(nTECW7RecHits);
01168 for (int i = 0; i < nTECW7RecHits; ++i) {
01169 TECW7RecHits[i].RX = rx[i];
01170 TECW7RecHits[i].RY = ry[i];
01171 TECW7RecHits[i].SX = sx[i];
01172 TECW7RecHits[i].SY = sy[i];
01173 }
01174
01175 return;
01176 }
01177
01178 void PGlobalRecHit::putTECW8RecHits(const std::vector<float>& rx,
01179 const std::vector<float>& ry,
01180 const std::vector<float>& sx,
01181 const std::vector<float>& sy)
01182 {
01183 nTECW8RecHits = rx.size();
01184 TECW8RecHits.resize(nTECW8RecHits);
01185 for (int i = 0; i < nTECW8RecHits; ++i) {
01186 TECW8RecHits[i].RX = rx[i];
01187 TECW8RecHits[i].RY = ry[i];
01188 TECW8RecHits[i].SX = sx[i];
01189 TECW8RecHits[i].SY = sy[i];
01190 }
01191
01192 return;
01193 }
01194
01195 void PGlobalRecHit::putBRL1RecHits(const std::vector<float>& rx,
01196 const std::vector<float>& ry,
01197 const std::vector<float>& sx,
01198 const std::vector<float>& sy)
01199 {
01200 nBRL1RecHits = rx.size();
01201 BRL1RecHits.resize(nBRL1RecHits);
01202 for (int i = 0; i < nBRL1RecHits; ++i) {
01203 BRL1RecHits[i].RX = rx[i];
01204 BRL1RecHits[i].RY = ry[i];
01205 BRL1RecHits[i].SX = sx[i];
01206 BRL1RecHits[i].SY = sy[i];
01207 }
01208
01209 return;
01210 }
01211
01212 void PGlobalRecHit::putBRL2RecHits(const std::vector<float>& rx,
01213 const std::vector<float>& ry,
01214 const std::vector<float>& sx,
01215 const std::vector<float>& sy)
01216 {
01217 nBRL2RecHits = rx.size();
01218 BRL2RecHits.resize(nBRL2RecHits);
01219 for (int i = 0; i < nBRL2RecHits; ++i) {
01220 BRL2RecHits[i].RX = rx[i];
01221 BRL2RecHits[i].RY = ry[i];
01222 BRL2RecHits[i].SX = sx[i];
01223 BRL2RecHits[i].SY = sy[i];
01224 }
01225
01226 return;
01227 }
01228
01229 void PGlobalRecHit::putBRL3RecHits(const std::vector<float>& rx,
01230 const std::vector<float>& ry,
01231 const std::vector<float>& sx,
01232 const std::vector<float>& sy)
01233 {
01234 nBRL3RecHits = rx.size();
01235 BRL3RecHits.resize(nBRL3RecHits);
01236 for (int i = 0; i < nBRL3RecHits; ++i) {
01237 BRL3RecHits[i].RX = rx[i];
01238 BRL3RecHits[i].RY = ry[i];
01239 BRL3RecHits[i].SX = sx[i];
01240 BRL3RecHits[i].SY = sy[i];
01241 }
01242
01243 return;
01244 }
01245
01246 void PGlobalRecHit::putFWD1pRecHits(const std::vector<float>& rx,
01247 const std::vector<float>& ry,
01248 const std::vector<float>& sx,
01249 const std::vector<float>& sy)
01250 {
01251 nFWD1pRecHits = rx.size();
01252 FWD1pRecHits.resize(nFWD1pRecHits);
01253 for (int i = 0; i < nFWD1pRecHits; ++i) {
01254 FWD1pRecHits[i].RX = rx[i];
01255 FWD1pRecHits[i].RY = ry[i];
01256 FWD1pRecHits[i].SX = sx[i];
01257 FWD1pRecHits[i].SY = sy[i];
01258 }
01259
01260 return;
01261 }
01262
01263 void PGlobalRecHit::putFWD1nRecHits(const std::vector<float>& rx,
01264 const std::vector<float>& ry,
01265 const std::vector<float>& sx,
01266 const std::vector<float>& sy)
01267 {
01268 nFWD1nRecHits = rx.size();
01269 FWD1nRecHits.resize(nFWD1nRecHits);
01270 for (int i = 0; i < nFWD1nRecHits; ++i) {
01271 FWD1nRecHits[i].RX = rx[i];
01272 FWD1nRecHits[i].RY = ry[i];
01273 FWD1nRecHits[i].SX = sx[i];
01274 FWD1nRecHits[i].SY = sy[i];
01275 }
01276
01277 return;
01278 }
01279
01280 void PGlobalRecHit::putFWD2pRecHits(const std::vector<float>& rx,
01281 const std::vector<float>& ry,
01282 const std::vector<float>& sx,
01283 const std::vector<float>& sy)
01284 {
01285 nFWD2pRecHits = rx.size();
01286 FWD2pRecHits.resize(nFWD2pRecHits);
01287 for (int i = 0; i < nFWD2pRecHits; ++i) {
01288 FWD2pRecHits[i].RX = rx[i];
01289 FWD2pRecHits[i].RY = ry[i];
01290 FWD2pRecHits[i].SX = sx[i];
01291 FWD2pRecHits[i].SY = sy[i];
01292 }
01293
01294 return;
01295 }
01296
01297 void PGlobalRecHit::putFWD2nRecHits(const std::vector<float>& rx,
01298 const std::vector<float>& ry,
01299 const std::vector<float>& sx,
01300 const std::vector<float>& sy)
01301 {
01302 nFWD2nRecHits = rx.size();
01303 FWD2nRecHits.resize(nFWD2nRecHits);
01304 for (int i = 0; i < nFWD2nRecHits; ++i) {
01305 FWD2nRecHits[i].RX = rx[i];
01306 FWD2nRecHits[i].RY = ry[i];
01307 FWD2nRecHits[i].SX = sx[i];
01308 FWD2nRecHits[i].SY = sy[i];
01309 }
01310
01311 return;
01312 }
01313
01314 void PGlobalRecHit::putDTRecHits(const std::vector<float>& rhd,
01315 const std::vector<float>& shd)
01316 {
01317 nDTRecHits = rhd.size();
01318 DTRecHits.resize(nDTRecHits);
01319 for (int i = 0; i < nDTRecHits; ++i) {
01320 DTRecHits[i].RHD = rhd[i];
01321 DTRecHits[i].SHD = shd[i];
01322 }
01323
01324 return;
01325 }
01326
01327 void PGlobalRecHit::putCSCRecHits(const std::vector<float>& rhphi,
01328 const std::vector<float>& rhperp,
01329 const std::vector<float>& shphi)
01330 {
01331 nCSCRecHits = rhphi.size();
01332 CSCRecHits.resize(nCSCRecHits);
01333 for (int i = 0; i < nCSCRecHits; ++i) {
01334 CSCRecHits[i].RHPHI = rhphi[i];
01335 CSCRecHits[i].RHPERP = rhperp[i];
01336 CSCRecHits[i].SHPHI = shphi[i];
01337 }
01338
01339 return;
01340 }
01341
01342 void PGlobalRecHit::putRPCRecHits(const std::vector<float>& rhx,
01343 const std::vector<float>& shx)
01344 {
01345 nRPCRecHits = rhx.size();
01346 RPCRecHits.resize(nRPCRecHits);
01347 for (int i = 0; i < nRPCRecHits; ++i) {
01348 RPCRecHits[i].RHX = rhx[i];
01349 RPCRecHits[i].SHX = shx[i];
01350 }
01351
01352 return;
01353 }
01354
01356
01358
01359 void PHcalValidInfoJets::fillTProfileJet(double e, double r, double t) {
01360 jetHite.push_back((float)e);
01361 jetHitr.push_back((float)r);
01362 jetHitt.push_back((float)t);
01363 nJetHit++;
01364
01365
01366
01367 }
01368
01369 void PHcalValidInfoJets::fillEcollectJet(double ee, double he,
01370 double hoe, double etot) {
01371
01372
01373 ecalJet = (float)ee;
01374 hcalJet = (float)he;
01375 hoJet = (float)hoe;
01376 etotJet = (float)etot;
01377 }
01378
01379 void PHcalValidInfoJets::fillEtaPhiProfileJet(double eta0, double phi0,
01380 double eta, double phi,
01381 double dist) {
01382 detaJet = (float)(eta-eta0);
01383 dphiJet = (float)(phi-phi0);
01384 drJet = (float)dist;
01385 }
01386
01387 void PHcalValidInfoJets::fillJets(const std::vector<double>& en,
01388 const std::vector<double>& eta,
01389 const std::vector<double>& phi) {
01390 nJet = en.size();
01391 for (int i = 0; i < nJet; i++) {
01392 jetE.push_back((float)en[i]);
01393 jetEta.push_back((float)eta[i]);
01394 jetPhi.push_back((float)phi[i]);
01395 }
01396
01397
01398
01399 }
01400
01401 void PHcalValidInfoJets::fillDiJets(double mass) {
01402 dijetM = (float)mass;
01403 }
01404
01406
01408
01409 void PHcalValidInfoLayer::fillLayers(double el[], double ed[], double ho,
01410 double hbhe, double ebee) {
01411
01412 for (int i = 0; i < 20; i++) {
01413 double en = 0.001*el[i];
01414 eLayer.push_back((float)en);
01415 }
01416 for (int i = 0; i < 4; i++) {
01417 double en = 0.001*ed[i];
01418 eDepth.push_back((float)en);
01419 }
01420 eHO = (float)ho;
01421 eHBHE = (float)hbhe;
01422 eEBEE = (float)ebee;
01423 }
01424
01425 void PHcalValidInfoLayer::fillHF(double fibl, double fibs, double enec,
01426 double enhc) {
01427 elongHF = (float)fibl;
01428 eshortHF = (float)fibs;
01429 eEcalHF = (float)enec;
01430 eHcalHF = (float)enhc;
01431 }
01432
01433 void PHcalValidInfoLayer::fillHits(int nHits, int lay, int unitID, double eta,
01434 double phi, double ehit, double t){
01435
01436 hitLayer.push_back((float)lay);
01437 hitId.push_back((float)unitID);
01438 hitEta.push_back((float)eta);
01439 hitPhi.push_back((float)phi);
01440 hitE.push_back((float)ehit);
01441 hitTime.push_back((float)t);
01442 hitN++;
01443
01444
01445
01446 }
01447
01449
01451
01452 void PHcalValidInfoNxN::fillHvsE(double ee, double he, double hoe,
01453 double etot) {
01454 ecalNxNr = (float)ee;
01455 hcalNxNr = (float)he;
01456 hoNxNr = (float)hoe;
01457 etotNxNr = (float)etot;
01458 }
01459
01460 void PHcalValidInfoNxN::fillEcollectNxN(double een, double hen, double hoen,
01461 double etotn) {
01462 ecalNxN = (float)een;
01463 hcalNxN = (float)hen;
01464 hoNxN = (float)hoen;
01465 etotNxN = (float)etotn;
01466 }
01467
01468 void PHcalValidInfoNxN::fillTProfileNxN (double e, int i, double t) {
01469 idNxN.push_back((float)i);
01470 eNxN.push_back((float)e);
01471 tNxN.push_back((float)t);
01472 nNxN++;
01473
01474
01475
01476 }
01477
01479
01481
01482 void PMuonSimHit::putRawGenPart(int n)
01483 {
01484 nRawGenPart = n;
01485 return;
01486 }
01487
01488 void PMuonSimHit::putG4Vtx(const std::vector<float>& x, const std::vector<float>& y,
01489 const std::vector<float>& z)
01490 {
01491 nG4Vtx = x.size();
01492 G4Vtx.resize(nG4Vtx);
01493 for (int i = 0; i < nG4Vtx; ++i) {
01494 G4Vtx[i].x = x[i];
01495 G4Vtx[i].y = y[i];
01496 G4Vtx[i].z = z[i];
01497 }
01498 return;
01499 }
01500
01501 void PMuonSimHit::putG4Trk(const std::vector<float>& pt, const std::vector<float>& e,
01502 const std::vector<float>& eta, const std::vector<float>& phi)
01503 {
01504 nG4Trk = pt.size();
01505 G4Trk.resize(nG4Trk);
01506 for (int i = 0; i < nG4Trk; ++i) {
01507 G4Trk[i].pt = pt[i];
01508 G4Trk[i].e = e[i];
01509 G4Trk[i].eta = eta[i];
01510 G4Trk[i].phi = phi[i];
01511 }
01512 return;
01513 }
01514
01515 void PMuonSimHit::putCSCHits (
01516 const std::vector<int>& _cscId,
01517 const std::vector<unsigned int>& _detUnitId,
01518 const std::vector<float>& _trackId ,
01519 const std::vector<float>& _processType,
01520 const std::vector<float>& _particleType,
01521 const std::vector<float>& _pabs,
01522 const std::vector<float>& _globposz,
01523 const std::vector<float>& _globposphi,
01524 const std::vector<float>& _globposeta,
01525 const std::vector<float>& _locposx,
01526 const std::vector<float>& _locposy,
01527 const std::vector<float>& _locposz,
01528 const std::vector<float>& _locdirx,
01529 const std::vector<float>& _locdiry,
01530 const std::vector<float>& _locdirz,
01531 const std::vector<float>& _locdirtheta,
01532 const std::vector<float>& _locdirphi,
01533 const std::vector<float>& _exitpointx,
01534 const std::vector<float>& _exitpointy,
01535 const std::vector<float>& _exitpointz,
01536 const std::vector<float>& _entrypointx,
01537 const std::vector<float>& _entrypointy,
01538 const std::vector<float>& _entrypointz,
01539 const std::vector<float>& _enloss,
01540 const std::vector<float>& _tof)
01541
01542 {
01543 nCSCHits = _tof.size();
01544 CSCHits.resize(nCSCHits);
01545 for (int i = 0; i < nCSCHits; ++i) {
01546 CSCHits[i]._cscId = _cscId[i];
01547 CSCHits[i]._detUnitId = _detUnitId[i];
01548 CSCHits[i]._trackId = _trackId[i];
01549 CSCHits[i]._processType = _processType[i];
01550 CSCHits[i]._particleType = _particleType[i];
01551 CSCHits[i]._pabs = _pabs[i];
01552 CSCHits[i]._globposz = _globposz[i];
01553 CSCHits[i]._globposphi = _globposphi[i];
01554 CSCHits[i]._globposeta = _globposeta[i];
01555 CSCHits[i]._locposx = _locposx[i];
01556 CSCHits[i]._locposy = _locposy[i];
01557 CSCHits[i]._locposz = _locposz[i];
01558 CSCHits[i]._locdirx = _locdirx[i];
01559 CSCHits[i]._locdiry = _locdiry[i];
01560 CSCHits[i]._locdirz = _locdirz[i];
01561 CSCHits[i]._locdirtheta = _locdirtheta[i];
01562 CSCHits[i]._locdirphi = _locdirphi[i];
01563 CSCHits[i]._exitpointx = _exitpointx[i];
01564 CSCHits[i]._exitpointy = _exitpointy[i];
01565 CSCHits[i]._exitpointz = _exitpointz[i];
01566 CSCHits[i]._entrypointx = _entrypointx[i];
01567 CSCHits[i]._entrypointy = _entrypointy[i];
01568 CSCHits[i]._entrypointz = _entrypointz[i];
01569 CSCHits[i]._enloss = _enloss[i];
01570 CSCHits[i]._tof = _tof[i];
01571 }
01572 return;
01573 }
01574
01575 void PMuonSimHit::putDTHits (const std::vector<unsigned int>& _detUnitId,
01576 const std::vector<float>& _trackId ,
01577 const std::vector<float>& _processType,
01578 const std::vector<float>& _particleType,
01579 const std::vector<float>& _pabs,
01580 const std::vector<float>& _globposz,
01581 const std::vector<float>& _globposphi,
01582 const std::vector<float>& _globposeta,
01583 const std::vector<float>& _locposx,
01584 const std::vector<float>& _locposy,
01585 const std::vector<float>& _locposz,
01586 const std::vector<float>& _locdirx,
01587 const std::vector<float>& _locdiry,
01588 const std::vector<float>& _locdirz,
01589 const std::vector<float>& _locdirtheta,
01590 const std::vector<float>& _locdirphi,
01591 const std::vector<float>& _exitpointx,
01592 const std::vector<float>& _exitpointy,
01593 const std::vector<float>& _exitpointz,
01594 const std::vector<float>& _entrypointx,
01595 const std::vector<float>& _entrypointy,
01596 const std::vector<float>& _entrypointz,
01597 const std::vector<float>& _enloss,
01598 const std::vector<float>& _tof)
01599
01600 {
01601 nDTHits = _tof.size();
01602 DTHits.resize(nDTHits);
01603 for (int i = 0; i < nDTHits; ++i) {
01604 DTHits[i]._detUnitId = _detUnitId[i];
01605 DTHits[i]._trackId = _trackId[i];
01606 DTHits[i]._processType = _processType[i];
01607 DTHits[i]._particleType = _particleType[i];
01608 DTHits[i]._pabs = _pabs[i];
01609 DTHits[i]._globposz = _globposz[i];
01610 DTHits[i]._globposphi = _globposphi[i];
01611 DTHits[i]._globposeta = _globposeta[i];
01612 DTHits[i]._locposx = _locposx[i];
01613 DTHits[i]._locposy = _locposy[i];
01614 DTHits[i]._locposz = _locposz[i];
01615 DTHits[i]._locdirx = _locdirx[i];
01616 DTHits[i]._locdiry = _locdiry[i];
01617 DTHits[i]._locdirz = _locdirz[i];
01618 DTHits[i]._locdirtheta = _locdirtheta[i];
01619 DTHits[i]._locdirphi = _locdirphi[i];
01620 DTHits[i]._exitpointx = _exitpointx[i];
01621 DTHits[i]._exitpointy = _exitpointy[i];
01622 DTHits[i]._exitpointz = _exitpointz[i];
01623 DTHits[i]._entrypointx = _entrypointx[i];
01624 DTHits[i]._entrypointy = _entrypointy[i];
01625 DTHits[i]._entrypointz = _entrypointz[i];
01626 DTHits[i]._enloss = _enloss[i];
01627 DTHits[i]._tof = _tof[i];
01628 }
01629 return;
01630 }
01631
01632 void PMuonSimHit::putRPCHits (const std::vector<unsigned int>& _detUnitId,
01633 const std::vector<float>& _trackId ,
01634 const std::vector<float>& _processType,
01635 const std::vector<float>& _particleType,
01636 const std::vector<float>& _pabs,
01637 const std::vector<float>& _globposz,
01638 const std::vector<float>& _globposphi,
01639 const std::vector<float>& _globposeta,
01640 const std::vector<float>& _locposx,
01641 const std::vector<float>& _locposy,
01642 const std::vector<float>& _locposz,
01643 const std::vector<float>& _locdirx,
01644 const std::vector<float>& _locdiry,
01645 const std::vector<float>& _locdirz,
01646 const std::vector<float>& _locdirtheta,
01647 const std::vector<float>& _locdirphi,
01648 const std::vector<float>& _exitpointx,
01649 const std::vector<float>& _exitpointy,
01650 const std::vector<float>& _exitpointz,
01651 const std::vector<float>& _entrypointx,
01652 const std::vector<float>& _entrypointy,
01653 const std::vector<float>& _entrypointz,
01654 const std::vector<float>& _enloss,
01655 const std::vector<float>& _tof)
01656
01657 {
01658 nRPCHits = _tof.size();
01659 RPCHits.resize(nRPCHits);
01660 for (int i = 0; i < nRPCHits; ++i) {
01661 RPCHits[i]._detUnitId = _detUnitId[i];
01662 RPCHits[i]._trackId = _trackId[i];
01663 RPCHits[i]._processType = _processType[i];
01664 RPCHits[i]._particleType = _particleType[i];
01665 RPCHits[i]._pabs = _pabs[i];
01666 RPCHits[i]._globposz = _globposz[i];
01667 RPCHits[i]._globposphi = _globposphi[i];
01668 RPCHits[i]._globposeta = _globposeta[i];
01669 RPCHits[i]._locposx = _locposx[i];
01670 RPCHits[i]._locposy = _locposy[i];
01671 RPCHits[i]._locposz = _locposz[i];
01672 RPCHits[i]._locdirx = _locdirx[i];
01673 RPCHits[i]._locdiry = _locdiry[i];
01674 RPCHits[i]._locdirz = _locdirz[i];
01675 RPCHits[i]._locdirtheta = _locdirtheta[i];
01676 RPCHits[i]._locdirphi = _locdirphi[i];
01677 RPCHits[i]._exitpointx = _exitpointx[i];
01678 RPCHits[i]._exitpointy = _exitpointy[i];
01679 RPCHits[i]._exitpointz = _exitpointz[i];
01680 RPCHits[i]._entrypointx = _entrypointx[i];
01681 RPCHits[i]._entrypointy = _entrypointy[i];
01682 RPCHits[i]._entrypointz = _entrypointz[i];
01683 RPCHits[i]._enloss = _enloss[i];
01684 RPCHits[i]._tof = _tof[i];
01685 }
01686 return;
01687
01688 }
01689
01691
01693
01694 void PTrackerSimHit::putRawGenPart(int n)
01695 {
01696 nRawGenPart = n;
01697 return;
01698 }
01699
01700 void PTrackerSimHit::putG4Vtx(const std::vector<float>& x, const std::vector<float>& y,
01701 const std::vector<float>& z)
01702 {
01703 nG4Vtx = x.size();
01704 G4Vtx.resize(nG4Vtx);
01705 for (int i = 0; i < nG4Vtx; ++i) {
01706 G4Vtx[i].x = x[i];
01707 G4Vtx[i].y = y[i];
01708 G4Vtx[i].z = z[i];
01709 }
01710
01711 return;
01712 }
01713
01714 void PTrackerSimHit::putG4Trk(const std::vector<float>& pt, const std::vector<float>& e,
01715 const std::vector<float>& eta, const std::vector<float>& phi)
01716 {
01717 nG4Trk = pt.size();
01718 G4Trk.resize(nG4Trk);
01719 for (int i = 0; i < nG4Trk; ++i) {
01720 G4Trk[i].pt = pt[i];
01721 G4Trk[i].e = e[i];
01722 G4Trk[i].eta = eta[i];
01723 G4Trk[i].phi = phi[i];
01724 }
01725
01726 return;
01727 }
01728
01729
01730 void PTrackerSimHit::putHits (const std::vector<int>& _sysID, const std::vector<float>& _detUnitId,
01731 const std::vector<float>&_trackId , const std::vector<float>&_processType,
01732 const std::vector<float>&_particleType, const std::vector<float>& _pabs,
01733 const std::vector<float>&_lpx, const std::vector<float>&_lpy, const std::vector<float>&_lpz,
01734 const std::vector<float>&_ldx, const std::vector<float>&_ldy, const std::vector<float>&_ldz,
01735 const std::vector<float>&_ldtheta, const std::vector<float>&_ldphi,
01736 const std::vector<float>&_exx, const std::vector<float>&_exy, const std::vector<float>&_exz,
01737 const std::vector<float>&_enx, const std::vector<float>&_eny, const std::vector<float>&_enz,
01738 const std::vector<float>&_eloss, const std::vector<float>&_tof)
01739
01740 {
01741 nHits = _tof.size();
01742 Hits.resize(nHits);
01743 for (int i = 0; i < nHits; ++i) {
01744 Hits[i]._sysID = _sysID[i];
01745 Hits[i]._detUnitId = _detUnitId[i];
01746 Hits[i]._trackId = _trackId[i];
01747 Hits[i]._processType = _processType[i];
01748 Hits[i]._particleType = _particleType[i];
01749 Hits[i]._pabs = _pabs[i];
01750 Hits[i]._lpx = _lpx[i];
01751 Hits[i]._lpy = _lpy[i];
01752 Hits[i]._lpz = _lpz[i];
01753 Hits[i]._ldx = _ldx[i];
01754 Hits[i]._ldy = _ldy[i];
01755 Hits[i]._ldz = _ldz[i];
01756 Hits[i]._ldtheta = _ldtheta[i];
01757 Hits[i]._ldphi = _ldphi[i];
01758 Hits[i]._exx = _exx[i];
01759 Hits[i]._exy = _exy[i];
01760 Hits[i]._exz = _exz[i];
01761 Hits[i]._enx = _enx[i];
01762 Hits[i]._eny = _eny[i];
01763 Hits[i]._enz = _enz[i];
01764 Hits[i]._eloss = _eloss[i];
01765 Hits[i]._tof = _tof[i];
01766 }
01767
01768 return;
01769 }
01770
1.7.3