Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:29:45 

0001 /** \file PValidationFormats.cc
0002  *  
0003  *  See header file for description of classes
0004  *  conglomoration of all Validation SimDataFormats
0005  *
0006  *  \author M. Strang SUNY-Buffalo
0007  */
0008 
0009 #include "SimDataFormats/ValidationFormats/interface/PValidationFormats.h"
0010 
0011 ///////////////////////////////////////////////////////////////////////////////
0012 // PGlobalSimHit
0013 ///////////////////////////////////////////////////////////////////////////////
0014 
0015 void PGlobalSimHit::putRawGenPart(int n) {
0016   nRawGenPart = n;
0017   return;
0018 }
0019 
0020 void PGlobalSimHit::putG4Vtx(const std::vector<float>& x, const std::vector<float>& y, const std::vector<float>& z) {
0021   nG4Vtx = x.size();
0022   G4Vtx.resize(nG4Vtx);
0023   for (int i = 0; i < nG4Vtx; ++i) {
0024     G4Vtx[i].x = x[i];
0025     G4Vtx[i].y = y[i];
0026     G4Vtx[i].z = z[i];
0027   }
0028 
0029   return;
0030 }
0031 
0032 void PGlobalSimHit::putG4Trk(const std::vector<float>& pt, const std::vector<float>& e) {
0033   nG4Trk = pt.size();
0034   G4Trk.resize(nG4Trk);
0035   for (int i = 0; i < nG4Trk; ++i) {
0036     G4Trk[i].pt = pt[i];
0037     G4Trk[i].e = e[i];
0038   }
0039 
0040   return;
0041 }
0042 
0043 void PGlobalSimHit::putECalHits(const std::vector<float>& e,
0044                                 const std::vector<float>& tof,
0045                                 const std::vector<float>& phi,
0046                                 const std::vector<float>& eta) {
0047   nECalHits = e.size();
0048   ECalHits.resize(nECalHits);
0049   for (int i = 0; i < nECalHits; ++i) {
0050     ECalHits[i].e = e[i];
0051     ECalHits[i].tof = tof[i];
0052     ECalHits[i].phi = phi[i];
0053     ECalHits[i].eta = eta[i];
0054   }
0055 
0056   return;
0057 }
0058 
0059 void PGlobalSimHit::putPreShHits(const std::vector<float>& e,
0060                                  const std::vector<float>& tof,
0061                                  const std::vector<float>& phi,
0062                                  const std::vector<float>& eta) {
0063   nPreShHits = e.size();
0064   PreShHits.resize(nPreShHits);
0065   for (int i = 0; i < nPreShHits; ++i) {
0066     PreShHits[i].e = e[i];
0067     PreShHits[i].tof = tof[i];
0068     PreShHits[i].phi = phi[i];
0069     PreShHits[i].eta = eta[i];
0070   }
0071 
0072   return;
0073 }
0074 
0075 void PGlobalSimHit::putHCalHits(const std::vector<float>& e,
0076                                 const std::vector<float>& tof,
0077                                 const std::vector<float>& phi,
0078                                 const std::vector<float>& eta) {
0079   nHCalHits = e.size();
0080   HCalHits.resize(nHCalHits);
0081   for (int i = 0; i < nHCalHits; ++i) {
0082     HCalHits[i].e = e[i];
0083     HCalHits[i].tof = tof[i];
0084     HCalHits[i].phi = phi[i];
0085     HCalHits[i].eta = eta[i];
0086   }
0087 
0088   return;
0089 }
0090 
0091 void PGlobalSimHit::putPxlFwdHits(const std::vector<float>& tof,
0092                                   const std::vector<float>& z,
0093                                   const std::vector<float>& phi,
0094                                   const std::vector<float>& eta) {
0095   nPxlFwdHits = tof.size();
0096   PxlFwdHits.resize(nPxlFwdHits);
0097   for (int i = 0; i < nPxlFwdHits; ++i) {
0098     PxlFwdHits[i].tof = tof[i];
0099     PxlFwdHits[i].z = z[i];
0100     PxlFwdHits[i].phi = phi[i];
0101     PxlFwdHits[i].eta = eta[i];
0102   }
0103 
0104   return;
0105 }
0106 
0107 void PGlobalSimHit::putPxlBrlHits(const std::vector<float>& tof,
0108                                   const std::vector<float>& r,
0109                                   const std::vector<float>& phi,
0110                                   const std::vector<float>& eta) {
0111   nPxlBrlHits = tof.size();
0112   PxlBrlHits.resize(nPxlBrlHits);
0113   for (int i = 0; i < nPxlBrlHits; ++i) {
0114     PxlBrlHits[i].tof = tof[i];
0115     PxlBrlHits[i].r = r[i];
0116     PxlBrlHits[i].phi = phi[i];
0117     PxlBrlHits[i].eta = eta[i];
0118   }
0119 
0120   return;
0121 }
0122 
0123 void PGlobalSimHit::putSiFwdHits(const std::vector<float>& tof,
0124                                  const std::vector<float>& z,
0125                                  const std::vector<float>& phi,
0126                                  const std::vector<float>& eta) {
0127   nSiFwdHits = tof.size();
0128   SiFwdHits.resize(nSiFwdHits);
0129   for (int i = 0; i < nSiFwdHits; ++i) {
0130     SiFwdHits[i].tof = tof[i];
0131     SiFwdHits[i].z = z[i];
0132     SiFwdHits[i].phi = phi[i];
0133     SiFwdHits[i].eta = eta[i];
0134   }
0135 
0136   return;
0137 }
0138 
0139 void PGlobalSimHit::putSiBrlHits(const std::vector<float>& tof,
0140                                  const std::vector<float>& r,
0141                                  const std::vector<float>& phi,
0142                                  const std::vector<float>& eta) {
0143   nSiBrlHits = tof.size();
0144   SiBrlHits.resize(nSiBrlHits);
0145   for (int i = 0; i < nSiBrlHits; ++i) {
0146     SiBrlHits[i].tof = tof[i];
0147     SiBrlHits[i].r = r[i];
0148     SiBrlHits[i].phi = phi[i];
0149     SiBrlHits[i].eta = eta[i];
0150   }
0151 
0152   return;
0153 }
0154 
0155 void PGlobalSimHit::putMuonCscHits(const std::vector<float>& tof,
0156                                    const std::vector<float>& z,
0157                                    const std::vector<float>& phi,
0158                                    const std::vector<float>& eta) {
0159   nMuonCscHits = tof.size();
0160   MuonCscHits.resize(nMuonCscHits);
0161   for (int i = 0; i < nMuonCscHits; ++i) {
0162     MuonCscHits[i].tof = tof[i];
0163     MuonCscHits[i].z = z[i];
0164     MuonCscHits[i].phi = phi[i];
0165     MuonCscHits[i].eta = eta[i];
0166   }
0167 
0168   return;
0169 }
0170 
0171 void PGlobalSimHit::putMuonDtHits(const std::vector<float>& tof,
0172                                   const std::vector<float>& r,
0173                                   const std::vector<float>& phi,
0174                                   const std::vector<float>& eta) {
0175   nMuonDtHits = tof.size();
0176   MuonDtHits.resize(nMuonDtHits);
0177   for (int i = 0; i < nMuonDtHits; ++i) {
0178     MuonDtHits[i].tof = tof[i];
0179     MuonDtHits[i].r = r[i];
0180     MuonDtHits[i].phi = phi[i];
0181     MuonDtHits[i].eta = eta[i];
0182   }
0183 
0184   return;
0185 }
0186 
0187 void PGlobalSimHit::putMuonRpcFwdHits(const std::vector<float>& tof,
0188                                       const std::vector<float>& z,
0189                                       const std::vector<float>& phi,
0190                                       const std::vector<float>& eta) {
0191   nMuonRpcFwdHits = tof.size();
0192   MuonRpcFwdHits.resize(nMuonRpcFwdHits);
0193   for (int i = 0; i < nMuonRpcFwdHits; ++i) {
0194     MuonRpcFwdHits[i].tof = tof[i];
0195     MuonRpcFwdHits[i].z = z[i];
0196     MuonRpcFwdHits[i].phi = phi[i];
0197     MuonRpcFwdHits[i].eta = eta[i];
0198   }
0199 
0200   return;
0201 }
0202 
0203 void PGlobalSimHit::putMuonRpcBrlHits(const std::vector<float>& tof,
0204                                       const std::vector<float>& r,
0205                                       const std::vector<float>& phi,
0206                                       const std::vector<float>& eta) {
0207   nMuonRpcBrlHits = tof.size();
0208   MuonRpcBrlHits.resize(nMuonRpcBrlHits);
0209   for (int i = 0; i < nMuonRpcBrlHits; ++i) {
0210     MuonRpcBrlHits[i].tof = tof[i];
0211     MuonRpcBrlHits[i].r = r[i];
0212     MuonRpcBrlHits[i].phi = phi[i];
0213     MuonRpcBrlHits[i].eta = eta[i];
0214   }
0215 
0216   return;
0217 }
0218 
0219 ///////////////////////////////////////////////////////////////////////////////
0220 // PGlobalDigi
0221 ///////////////////////////////////////////////////////////////////////////////
0222 
0223 void PGlobalDigi::putEBCalDigis(const std::vector<int>& maxpos,
0224                                 const std::vector<double>& aee,
0225                                 const std::vector<float>& she) {
0226   nEBCalDigis = maxpos.size();
0227   EBCalDigis.resize(nEBCalDigis);
0228   for (int i = 0; i < nEBCalDigis; ++i) {
0229     EBCalDigis[i].maxPos = maxpos[i];
0230     EBCalDigis[i].AEE = aee[i];
0231     EBCalDigis[i].SHE = she[i];
0232   }
0233 
0234   return;
0235 }
0236 
0237 void PGlobalDigi::putEECalDigis(const std::vector<int>& maxpos,
0238                                 const std::vector<double>& aee,
0239                                 const std::vector<float>& she) {
0240   nEECalDigis = maxpos.size();
0241   EECalDigis.resize(nEECalDigis);
0242   for (int i = 0; i < nEECalDigis; ++i) {
0243     EECalDigis[i].maxPos = maxpos[i];
0244     EECalDigis[i].AEE = aee[i];
0245     EECalDigis[i].SHE = she[i];
0246   }
0247 
0248   return;
0249 }
0250 
0251 void PGlobalDigi::putESCalDigis(const std::vector<float>& adc0,
0252                                 const std::vector<float>& adc1,
0253                                 const std::vector<float>& adc2,
0254                                 const std::vector<float>& she) {
0255   nESCalDigis = adc0.size();
0256   ESCalDigis.resize(nESCalDigis);
0257   for (int i = 0; i < nESCalDigis; ++i) {
0258     ESCalDigis[i].ADC0 = adc0[i];
0259     ESCalDigis[i].ADC1 = adc1[i];
0260     ESCalDigis[i].ADC2 = adc2[i];
0261     ESCalDigis[i].SHE = she[i];
0262   }
0263 
0264   return;
0265 }
0266 
0267 void PGlobalDigi::putHBCalDigis(const std::vector<float>& aee, const std::vector<float>& she) {
0268   nHBCalDigis = aee.size();
0269   HBCalDigis.resize(nHBCalDigis);
0270   for (int i = 0; i < nHBCalDigis; ++i) {
0271     HBCalDigis[i].AEE = aee[i];
0272     HBCalDigis[i].SHE = she[i];
0273   }
0274 
0275   return;
0276 }
0277 
0278 void PGlobalDigi::putHECalDigis(const std::vector<float>& aee, const std::vector<float>& she) {
0279   nHECalDigis = aee.size();
0280   HECalDigis.resize(nHECalDigis);
0281   for (int i = 0; i < nHECalDigis; ++i) {
0282     HECalDigis[i].AEE = aee[i];
0283     HECalDigis[i].SHE = she[i];
0284   }
0285 
0286   return;
0287 }
0288 
0289 void PGlobalDigi::putHOCalDigis(const std::vector<float>& aee, const std::vector<float>& she) {
0290   nHOCalDigis = aee.size();
0291   HOCalDigis.resize(nHOCalDigis);
0292   for (int i = 0; i < nHOCalDigis; ++i) {
0293     HOCalDigis[i].AEE = aee[i];
0294     HOCalDigis[i].SHE = she[i];
0295   }
0296 
0297   return;
0298 }
0299 
0300 void PGlobalDigi::putHFCalDigis(const std::vector<float>& aee, const std::vector<float>& she) {
0301   nHFCalDigis = aee.size();
0302   HFCalDigis.resize(nHFCalDigis);
0303   for (int i = 0; i < nHFCalDigis; ++i) {
0304     HFCalDigis[i].AEE = aee[i];
0305     HFCalDigis[i].SHE = she[i];
0306   }
0307 
0308   return;
0309 }
0310 
0311 void PGlobalDigi::putTIBL1Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0312   nTIBL1Digis = adc.size();
0313   TIBL1Digis.resize(nTIBL1Digis);
0314   for (int i = 0; i < nTIBL1Digis; ++i) {
0315     TIBL1Digis[i].ADC = adc[i];
0316     TIBL1Digis[i].STRIP = strip[i];
0317   }
0318 
0319   return;
0320 }
0321 
0322 void PGlobalDigi::putTIBL2Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0323   nTIBL2Digis = adc.size();
0324   TIBL2Digis.resize(nTIBL2Digis);
0325   for (int i = 0; i < nTIBL2Digis; ++i) {
0326     TIBL2Digis[i].ADC = adc[i];
0327     TIBL2Digis[i].STRIP = strip[i];
0328   }
0329 
0330   return;
0331 }
0332 
0333 void PGlobalDigi::putTIBL3Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0334   nTIBL3Digis = adc.size();
0335   TIBL3Digis.resize(nTIBL3Digis);
0336   for (int i = 0; i < nTIBL3Digis; ++i) {
0337     TIBL3Digis[i].ADC = adc[i];
0338     TIBL3Digis[i].STRIP = strip[i];
0339   }
0340 
0341   return;
0342 }
0343 
0344 void PGlobalDigi::putTIBL4Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0345   nTIBL4Digis = adc.size();
0346   TIBL4Digis.resize(nTIBL4Digis);
0347   for (int i = 0; i < nTIBL4Digis; ++i) {
0348     TIBL4Digis[i].ADC = adc[i];
0349     TIBL4Digis[i].STRIP = strip[i];
0350   }
0351 
0352   return;
0353 }
0354 
0355 void PGlobalDigi::putTOBL1Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0356   nTOBL1Digis = adc.size();
0357   TOBL1Digis.resize(nTOBL1Digis);
0358   for (int i = 0; i < nTOBL1Digis; ++i) {
0359     TOBL1Digis[i].ADC = adc[i];
0360     TOBL1Digis[i].STRIP = strip[i];
0361   }
0362 
0363   return;
0364 }
0365 
0366 void PGlobalDigi::putTOBL2Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0367   nTOBL2Digis = adc.size();
0368   TOBL2Digis.resize(nTOBL2Digis);
0369   for (int i = 0; i < nTOBL2Digis; ++i) {
0370     TOBL2Digis[i].ADC = adc[i];
0371     TOBL2Digis[i].STRIP = strip[i];
0372   }
0373 
0374   return;
0375 }
0376 
0377 void PGlobalDigi::putTOBL3Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0378   nTOBL3Digis = adc.size();
0379   TOBL3Digis.resize(nTOBL3Digis);
0380   for (int i = 0; i < nTOBL3Digis; ++i) {
0381     TOBL3Digis[i].ADC = adc[i];
0382     TOBL3Digis[i].STRIP = strip[i];
0383   }
0384 
0385   return;
0386 }
0387 
0388 void PGlobalDigi::putTOBL4Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0389   nTOBL4Digis = adc.size();
0390   TOBL4Digis.resize(nTOBL4Digis);
0391   for (int i = 0; i < nTOBL4Digis; ++i) {
0392     TOBL4Digis[i].ADC = adc[i];
0393     TOBL4Digis[i].STRIP = strip[i];
0394   }
0395 
0396   return;
0397 }
0398 
0399 void PGlobalDigi::putTIDW1Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0400   nTIDW1Digis = adc.size();
0401   TIDW1Digis.resize(nTIDW1Digis);
0402   for (int i = 0; i < nTIDW1Digis; ++i) {
0403     TIDW1Digis[i].ADC = adc[i];
0404     TIDW1Digis[i].STRIP = strip[i];
0405   }
0406 
0407   return;
0408 }
0409 
0410 void PGlobalDigi::putTIDW2Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0411   nTIDW2Digis = adc.size();
0412   TIDW2Digis.resize(nTIDW2Digis);
0413   for (int i = 0; i < nTIDW2Digis; ++i) {
0414     TIDW2Digis[i].ADC = adc[i];
0415     TIDW2Digis[i].STRIP = strip[i];
0416   }
0417 
0418   return;
0419 }
0420 
0421 void PGlobalDigi::putTIDW3Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0422   nTIDW3Digis = adc.size();
0423   TIDW3Digis.resize(nTIDW3Digis);
0424   for (int i = 0; i < nTIDW3Digis; ++i) {
0425     TIDW3Digis[i].ADC = adc[i];
0426     TIDW3Digis[i].STRIP = strip[i];
0427   }
0428 
0429   return;
0430 }
0431 
0432 void PGlobalDigi::putTECW1Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0433   nTECW1Digis = adc.size();
0434   TECW1Digis.resize(nTECW1Digis);
0435   for (int i = 0; i < nTECW1Digis; ++i) {
0436     TECW1Digis[i].ADC = adc[i];
0437     TECW1Digis[i].STRIP = strip[i];
0438   }
0439 
0440   return;
0441 }
0442 
0443 void PGlobalDigi::putTECW2Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0444   nTECW2Digis = adc.size();
0445   TECW2Digis.resize(nTECW2Digis);
0446   for (int i = 0; i < nTECW2Digis; ++i) {
0447     TECW2Digis[i].ADC = adc[i];
0448     TECW2Digis[i].STRIP = strip[i];
0449   }
0450 
0451   return;
0452 }
0453 
0454 void PGlobalDigi::putTECW3Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0455   nTECW3Digis = adc.size();
0456   TECW3Digis.resize(nTECW3Digis);
0457   for (int i = 0; i < nTECW3Digis; ++i) {
0458     TECW3Digis[i].ADC = adc[i];
0459     TECW3Digis[i].STRIP = strip[i];
0460   }
0461 
0462   return;
0463 }
0464 
0465 void PGlobalDigi::putTECW4Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0466   nTECW4Digis = adc.size();
0467   TECW4Digis.resize(nTECW4Digis);
0468   for (int i = 0; i < nTECW4Digis; ++i) {
0469     TECW4Digis[i].ADC = adc[i];
0470     TECW4Digis[i].STRIP = strip[i];
0471   }
0472 
0473   return;
0474 }
0475 
0476 void PGlobalDigi::putTECW5Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0477   nTECW5Digis = adc.size();
0478   TECW5Digis.resize(nTECW5Digis);
0479   for (int i = 0; i < nTECW5Digis; ++i) {
0480     TECW5Digis[i].ADC = adc[i];
0481     TECW5Digis[i].STRIP = strip[i];
0482   }
0483 
0484   return;
0485 }
0486 
0487 void PGlobalDigi::putTECW6Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0488   nTECW6Digis = adc.size();
0489   TECW6Digis.resize(nTECW6Digis);
0490   for (int i = 0; i < nTECW6Digis; ++i) {
0491     TECW6Digis[i].ADC = adc[i];
0492     TECW6Digis[i].STRIP = strip[i];
0493   }
0494 
0495   return;
0496 }
0497 
0498 void PGlobalDigi::putTECW7Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0499   nTECW7Digis = adc.size();
0500   TECW7Digis.resize(nTECW7Digis);
0501   for (int i = 0; i < nTECW7Digis; ++i) {
0502     TECW7Digis[i].ADC = adc[i];
0503     TECW7Digis[i].STRIP = strip[i];
0504   }
0505 
0506   return;
0507 }
0508 
0509 void PGlobalDigi::putTECW8Digis(const std::vector<float>& adc, const std::vector<int>& strip) {
0510   nTECW8Digis = adc.size();
0511   TECW8Digis.resize(nTECW8Digis);
0512   for (int i = 0; i < nTECW8Digis; ++i) {
0513     TECW8Digis[i].ADC = adc[i];
0514     TECW8Digis[i].STRIP = strip[i];
0515   }
0516 
0517   return;
0518 }
0519 
0520 void PGlobalDigi::putBRL1Digis(const std::vector<float>& adc,
0521                                const std::vector<int>& row,
0522                                const std::vector<int>& column) {
0523   nBRL1Digis = adc.size();
0524   BRL1Digis.resize(nBRL1Digis);
0525   for (int i = 0; i < nBRL1Digis; ++i) {
0526     BRL1Digis[i].ADC = adc[i];
0527     BRL1Digis[i].ROW = row[i];
0528     BRL1Digis[i].COLUMN = column[i];
0529   }
0530 
0531   return;
0532 }
0533 
0534 void PGlobalDigi::putBRL2Digis(const std::vector<float>& adc,
0535                                const std::vector<int>& row,
0536                                const std::vector<int>& column) {
0537   nBRL2Digis = adc.size();
0538   BRL2Digis.resize(nBRL2Digis);
0539   for (int i = 0; i < nBRL2Digis; ++i) {
0540     BRL2Digis[i].ADC = adc[i];
0541     BRL2Digis[i].ROW = row[i];
0542     BRL2Digis[i].COLUMN = column[i];
0543   }
0544 
0545   return;
0546 }
0547 
0548 void PGlobalDigi::putBRL3Digis(const std::vector<float>& adc,
0549                                const std::vector<int>& row,
0550                                const std::vector<int>& column) {
0551   nBRL3Digis = adc.size();
0552   BRL3Digis.resize(nBRL3Digis);
0553   for (int i = 0; i < nBRL3Digis; ++i) {
0554     BRL3Digis[i].ADC = adc[i];
0555     BRL3Digis[i].ROW = row[i];
0556     BRL3Digis[i].COLUMN = column[i];
0557   }
0558 
0559   return;
0560 }
0561 
0562 void PGlobalDigi::putFWD1pDigis(const std::vector<float>& adc,
0563                                 const std::vector<int>& row,
0564                                 const std::vector<int>& column) {
0565   nFWD1pDigis = adc.size();
0566   FWD1pDigis.resize(nFWD1pDigis);
0567   for (int i = 0; i < nFWD1pDigis; ++i) {
0568     FWD1pDigis[i].ADC = adc[i];
0569     FWD1pDigis[i].ROW = row[i];
0570     FWD1pDigis[i].COLUMN = column[i];
0571   }
0572 
0573   return;
0574 }
0575 
0576 void PGlobalDigi::putFWD1nDigis(const std::vector<float>& adc,
0577                                 const std::vector<int>& row,
0578                                 const std::vector<int>& column) {
0579   nFWD1nDigis = adc.size();
0580   FWD1nDigis.resize(nFWD1nDigis);
0581   for (int i = 0; i < nFWD1nDigis; ++i) {
0582     FWD1nDigis[i].ADC = adc[i];
0583     FWD1nDigis[i].ROW = row[i];
0584     FWD1nDigis[i].COLUMN = column[i];
0585   }
0586 
0587   return;
0588 }
0589 
0590 void PGlobalDigi::putFWD2pDigis(const std::vector<float>& adc,
0591                                 const std::vector<int>& row,
0592                                 const std::vector<int>& column) {
0593   nFWD2pDigis = adc.size();
0594   FWD2pDigis.resize(nFWD2pDigis);
0595   for (int i = 0; i < nFWD2pDigis; ++i) {
0596     FWD2pDigis[i].ADC = adc[i];
0597     FWD2pDigis[i].ROW = row[i];
0598     FWD2pDigis[i].COLUMN = column[i];
0599   }
0600 
0601   return;
0602 }
0603 
0604 void PGlobalDigi::putFWD2nDigis(const std::vector<float>& adc,
0605                                 const std::vector<int>& row,
0606                                 const std::vector<int>& column) {
0607   nFWD2nDigis = adc.size();
0608   FWD2nDigis.resize(nFWD2nDigis);
0609   for (int i = 0; i < nFWD2nDigis; ++i) {
0610     FWD2nDigis[i].ADC = adc[i];
0611     FWD2nDigis[i].ROW = row[i];
0612     FWD2nDigis[i].COLUMN = column[i];
0613   }
0614 
0615   return;
0616 }
0617 
0618 void PGlobalDigi::putMB1Digis(const std::vector<int>& slayer,
0619                               const std::vector<float>& time,
0620                               const std::vector<int>& layer) {
0621   nMB1Digis = slayer.size();
0622   MB1Digis.resize(nMB1Digis);
0623   for (int i = 0; i < nMB1Digis; ++i) {
0624     MB1Digis[i].SLAYER = slayer[i];
0625     MB1Digis[i].TIME = time[i];
0626     MB1Digis[i].LAYER = layer[i];
0627   }
0628 
0629   return;
0630 }
0631 
0632 void PGlobalDigi::putMB2Digis(const std::vector<int>& slayer,
0633                               const std::vector<float>& time,
0634                               const std::vector<int>& layer) {
0635   nMB2Digis = slayer.size();
0636   MB2Digis.resize(nMB2Digis);
0637   for (int i = 0; i < nMB2Digis; ++i) {
0638     MB2Digis[i].SLAYER = slayer[i];
0639     MB2Digis[i].TIME = time[i];
0640     MB2Digis[i].LAYER = layer[i];
0641   }
0642 
0643   return;
0644 }
0645 
0646 void PGlobalDigi::putMB3Digis(const std::vector<int>& slayer,
0647                               const std::vector<float>& time,
0648                               const std::vector<int>& layer) {
0649   nMB3Digis = slayer.size();
0650   MB3Digis.resize(nMB3Digis);
0651   for (int i = 0; i < nMB3Digis; ++i) {
0652     MB3Digis[i].SLAYER = slayer[i];
0653     MB3Digis[i].TIME = time[i];
0654     MB3Digis[i].LAYER = layer[i];
0655   }
0656 
0657   return;
0658 }
0659 
0660 void PGlobalDigi::putMB4Digis(const std::vector<int>& slayer,
0661                               const std::vector<float>& time,
0662                               const std::vector<int>& layer) {
0663   nMB4Digis = slayer.size();
0664   MB4Digis.resize(nMB4Digis);
0665   for (int i = 0; i < nMB4Digis; ++i) {
0666     MB4Digis[i].SLAYER = slayer[i];
0667     MB4Digis[i].TIME = time[i];
0668     MB4Digis[i].LAYER = layer[i];
0669   }
0670 
0671   return;
0672 }
0673 
0674 void PGlobalDigi::putCSCstripDigis(const std::vector<float>& adc) {
0675   nCSCstripDigis = adc.size();
0676   CSCstripDigis.resize(nCSCstripDigis);
0677   for (int i = 0; i < nCSCstripDigis; ++i) {
0678     CSCstripDigis[i].ADC = adc[i];
0679   }
0680 
0681   return;
0682 }
0683 
0684 void PGlobalDigi::putCSCwireDigis(const std::vector<float>& time) {
0685   nCSCwireDigis = time.size();
0686   CSCwireDigis.resize(nCSCwireDigis);
0687   for (int i = 0; i < nCSCwireDigis; ++i) {
0688     CSCwireDigis[i].TIME = time[i];
0689   }
0690 
0691   return;
0692 }
0693 
0694 ///////////////////////////////////////////////////////////////////////////////
0695 // PGlobalRecHit
0696 ///////////////////////////////////////////////////////////////////////////////
0697 
0698 void PGlobalRecHit::putEBCalRecHits(const std::vector<float>& re, const std::vector<float>& she) {
0699   nEBCalRecHits = re.size();
0700   EBCalRecHits.resize(nEBCalRecHits);
0701   for (int i = 0; i < nEBCalRecHits; ++i) {
0702     EBCalRecHits[i].RE = re[i];
0703     EBCalRecHits[i].SHE = she[i];
0704   }
0705 
0706   return;
0707 }
0708 
0709 void PGlobalRecHit::putEECalRecHits(const std::vector<float>& re, const std::vector<float>& she) {
0710   nEECalRecHits = re.size();
0711   EECalRecHits.resize(nEECalRecHits);
0712   for (int i = 0; i < nEECalRecHits; ++i) {
0713     EECalRecHits[i].RE = re[i];
0714     EECalRecHits[i].SHE = she[i];
0715   }
0716 
0717   return;
0718 }
0719 
0720 void PGlobalRecHit::putESCalRecHits(const std::vector<float>& re, const std::vector<float>& she) {
0721   nESCalRecHits = re.size();
0722   ESCalRecHits.resize(nESCalRecHits);
0723   for (int i = 0; i < nESCalRecHits; ++i) {
0724     ESCalRecHits[i].RE = re[i];
0725     ESCalRecHits[i].SHE = she[i];
0726   }
0727 
0728   return;
0729 }
0730 
0731 void PGlobalRecHit::putHBCalRecHits(const std::vector<float>& rec,
0732                                     const std::vector<float>& r,
0733                                     const std::vector<float>& she) {
0734   nHBCalRecHits = rec.size();
0735   HBCalRecHits.resize(nHBCalRecHits);
0736   for (int i = 0; i < nHBCalRecHits; ++i) {
0737     HBCalRecHits[i].REC = rec[i];
0738     HBCalRecHits[i].R = r[i];
0739     HBCalRecHits[i].SHE = she[i];
0740   }
0741 
0742   return;
0743 }
0744 
0745 void PGlobalRecHit::putHECalRecHits(const std::vector<float>& rec,
0746                                     const std::vector<float>& r,
0747                                     const std::vector<float>& she) {
0748   nHECalRecHits = rec.size();
0749   HECalRecHits.resize(nHECalRecHits);
0750   for (int i = 0; i < nHECalRecHits; ++i) {
0751     HECalRecHits[i].REC = rec[i];
0752     HECalRecHits[i].R = r[i];
0753     HECalRecHits[i].SHE = she[i];
0754   }
0755 
0756   return;
0757 }
0758 
0759 void PGlobalRecHit::putHOCalRecHits(const std::vector<float>& rec,
0760                                     const std::vector<float>& r,
0761                                     const std::vector<float>& she) {
0762   nHOCalRecHits = rec.size();
0763   HOCalRecHits.resize(nHOCalRecHits);
0764   for (int i = 0; i < nHOCalRecHits; ++i) {
0765     HOCalRecHits[i].REC = rec[i];
0766     HOCalRecHits[i].R = r[i];
0767     HOCalRecHits[i].SHE = she[i];
0768   }
0769 
0770   return;
0771 }
0772 
0773 void PGlobalRecHit::putHFCalRecHits(const std::vector<float>& rec,
0774                                     const std::vector<float>& r,
0775                                     const std::vector<float>& she) {
0776   nHFCalRecHits = rec.size();
0777   HFCalRecHits.resize(nHFCalRecHits);
0778   for (int i = 0; i < nHFCalRecHits; ++i) {
0779     HFCalRecHits[i].REC = rec[i];
0780     HFCalRecHits[i].R = r[i];
0781     HFCalRecHits[i].SHE = she[i];
0782   }
0783 
0784   return;
0785 }
0786 
0787 void PGlobalRecHit::putTIBL1RecHits(const std::vector<float>& rx,
0788                                     const std::vector<float>& ry,
0789                                     const std::vector<float>& sx,
0790                                     const std::vector<float>& sy) {
0791   nTIBL1RecHits = rx.size();
0792   TIBL1RecHits.resize(nTIBL1RecHits);
0793   for (int i = 0; i < nTIBL1RecHits; ++i) {
0794     TIBL1RecHits[i].RX = rx[i];
0795     TIBL1RecHits[i].RY = ry[i];
0796     TIBL1RecHits[i].SX = sx[i];
0797     TIBL1RecHits[i].SY = sy[i];
0798   }
0799 
0800   return;
0801 }
0802 
0803 void PGlobalRecHit::putTIBL2RecHits(const std::vector<float>& rx,
0804                                     const std::vector<float>& ry,
0805                                     const std::vector<float>& sx,
0806                                     const std::vector<float>& sy) {
0807   nTIBL2RecHits = rx.size();
0808   TIBL2RecHits.resize(nTIBL2RecHits);
0809   for (int i = 0; i < nTIBL2RecHits; ++i) {
0810     TIBL2RecHits[i].RX = rx[i];
0811     TIBL2RecHits[i].RY = ry[i];
0812     TIBL2RecHits[i].SX = sx[i];
0813     TIBL2RecHits[i].SY = sy[i];
0814   }
0815 
0816   return;
0817 }
0818 
0819 void PGlobalRecHit::putTIBL3RecHits(const std::vector<float>& rx,
0820                                     const std::vector<float>& ry,
0821                                     const std::vector<float>& sx,
0822                                     const std::vector<float>& sy) {
0823   nTIBL3RecHits = rx.size();
0824   TIBL3RecHits.resize(nTIBL3RecHits);
0825   for (int i = 0; i < nTIBL3RecHits; ++i) {
0826     TIBL3RecHits[i].RX = rx[i];
0827     TIBL3RecHits[i].RY = ry[i];
0828     TIBL3RecHits[i].SX = sx[i];
0829     TIBL3RecHits[i].SY = sy[i];
0830   }
0831 
0832   return;
0833 }
0834 
0835 void PGlobalRecHit::putTIBL4RecHits(const std::vector<float>& rx,
0836                                     const std::vector<float>& ry,
0837                                     const std::vector<float>& sx,
0838                                     const std::vector<float>& sy) {
0839   nTIBL4RecHits = rx.size();
0840   TIBL4RecHits.resize(nTIBL4RecHits);
0841   for (int i = 0; i < nTIBL4RecHits; ++i) {
0842     TIBL4RecHits[i].RX = rx[i];
0843     TIBL4RecHits[i].RY = ry[i];
0844     TIBL4RecHits[i].SX = sx[i];
0845     TIBL4RecHits[i].SY = sy[i];
0846   }
0847 
0848   return;
0849 }
0850 
0851 void PGlobalRecHit::putTOBL1RecHits(const std::vector<float>& rx,
0852                                     const std::vector<float>& ry,
0853                                     const std::vector<float>& sx,
0854                                     const std::vector<float>& sy) {
0855   nTOBL1RecHits = rx.size();
0856   TOBL1RecHits.resize(nTOBL1RecHits);
0857   for (int i = 0; i < nTOBL1RecHits; ++i) {
0858     TOBL1RecHits[i].RX = rx[i];
0859     TOBL1RecHits[i].RY = ry[i];
0860     TOBL1RecHits[i].SX = sx[i];
0861     TOBL1RecHits[i].SY = sy[i];
0862   }
0863 
0864   return;
0865 }
0866 
0867 void PGlobalRecHit::putTOBL2RecHits(const std::vector<float>& rx,
0868                                     const std::vector<float>& ry,
0869                                     const std::vector<float>& sx,
0870                                     const std::vector<float>& sy) {
0871   nTOBL2RecHits = rx.size();
0872   TOBL2RecHits.resize(nTOBL2RecHits);
0873   for (int i = 0; i < nTOBL2RecHits; ++i) {
0874     TOBL2RecHits[i].RX = rx[i];
0875     TOBL2RecHits[i].RY = ry[i];
0876     TOBL2RecHits[i].SX = sx[i];
0877     TOBL2RecHits[i].SY = sy[i];
0878   }
0879 
0880   return;
0881 }
0882 
0883 void PGlobalRecHit::putTOBL3RecHits(const std::vector<float>& rx,
0884                                     const std::vector<float>& ry,
0885                                     const std::vector<float>& sx,
0886                                     const std::vector<float>& sy) {
0887   nTOBL3RecHits = rx.size();
0888   TOBL3RecHits.resize(nTOBL3RecHits);
0889   for (int i = 0; i < nTOBL3RecHits; ++i) {
0890     TOBL3RecHits[i].RX = rx[i];
0891     TOBL3RecHits[i].RY = ry[i];
0892     TOBL3RecHits[i].SX = sx[i];
0893     TOBL3RecHits[i].SY = sy[i];
0894   }
0895 
0896   return;
0897 }
0898 
0899 void PGlobalRecHit::putTOBL4RecHits(const std::vector<float>& rx,
0900                                     const std::vector<float>& ry,
0901                                     const std::vector<float>& sx,
0902                                     const std::vector<float>& sy) {
0903   nTOBL4RecHits = rx.size();
0904   TOBL4RecHits.resize(nTOBL4RecHits);
0905   for (int i = 0; i < nTOBL4RecHits; ++i) {
0906     TOBL4RecHits[i].RX = rx[i];
0907     TOBL4RecHits[i].RY = ry[i];
0908     TOBL4RecHits[i].SX = sx[i];
0909     TOBL4RecHits[i].SY = sy[i];
0910   }
0911 
0912   return;
0913 }
0914 
0915 void PGlobalRecHit::putTIDW1RecHits(const std::vector<float>& rx,
0916                                     const std::vector<float>& ry,
0917                                     const std::vector<float>& sx,
0918                                     const std::vector<float>& sy) {
0919   nTIDW1RecHits = rx.size();
0920   TIDW1RecHits.resize(nTIDW1RecHits);
0921   for (int i = 0; i < nTIDW1RecHits; ++i) {
0922     TIDW1RecHits[i].RX = rx[i];
0923     TIDW1RecHits[i].RY = ry[i];
0924     TIDW1RecHits[i].SX = sx[i];
0925     TIDW1RecHits[i].SY = sy[i];
0926   }
0927 
0928   return;
0929 }
0930 
0931 void PGlobalRecHit::putTIDW2RecHits(const std::vector<float>& rx,
0932                                     const std::vector<float>& ry,
0933                                     const std::vector<float>& sx,
0934                                     const std::vector<float>& sy) {
0935   nTIDW2RecHits = rx.size();
0936   TIDW2RecHits.resize(nTIDW2RecHits);
0937   for (int i = 0; i < nTIDW2RecHits; ++i) {
0938     TIDW2RecHits[i].RX = rx[i];
0939     TIDW2RecHits[i].RY = ry[i];
0940     TIDW2RecHits[i].SX = sx[i];
0941     TIDW2RecHits[i].SY = sy[i];
0942   }
0943 
0944   return;
0945 }
0946 
0947 void PGlobalRecHit::putTIDW3RecHits(const std::vector<float>& rx,
0948                                     const std::vector<float>& ry,
0949                                     const std::vector<float>& sx,
0950                                     const std::vector<float>& sy) {
0951   nTIDW3RecHits = rx.size();
0952   TIDW3RecHits.resize(nTIDW3RecHits);
0953   for (int i = 0; i < nTIDW3RecHits; ++i) {
0954     TIDW3RecHits[i].RX = rx[i];
0955     TIDW3RecHits[i].RY = ry[i];
0956     TIDW3RecHits[i].SX = sx[i];
0957     TIDW3RecHits[i].SY = sy[i];
0958   }
0959 
0960   return;
0961 }
0962 
0963 void PGlobalRecHit::putTECW1RecHits(const std::vector<float>& rx,
0964                                     const std::vector<float>& ry,
0965                                     const std::vector<float>& sx,
0966                                     const std::vector<float>& sy) {
0967   nTECW1RecHits = rx.size();
0968   TECW1RecHits.resize(nTECW1RecHits);
0969   for (int i = 0; i < nTECW1RecHits; ++i) {
0970     TECW1RecHits[i].RX = rx[i];
0971     TECW1RecHits[i].RY = ry[i];
0972     TECW1RecHits[i].SX = sx[i];
0973     TECW1RecHits[i].SY = sy[i];
0974   }
0975 
0976   return;
0977 }
0978 
0979 void PGlobalRecHit::putTECW2RecHits(const std::vector<float>& rx,
0980                                     const std::vector<float>& ry,
0981                                     const std::vector<float>& sx,
0982                                     const std::vector<float>& sy) {
0983   nTECW2RecHits = rx.size();
0984   TECW2RecHits.resize(nTECW2RecHits);
0985   for (int i = 0; i < nTECW2RecHits; ++i) {
0986     TECW2RecHits[i].RX = rx[i];
0987     TECW2RecHits[i].RY = ry[i];
0988     TECW2RecHits[i].SX = sx[i];
0989     TECW2RecHits[i].SY = sy[i];
0990   }
0991 
0992   return;
0993 }
0994 
0995 void PGlobalRecHit::putTECW3RecHits(const std::vector<float>& rx,
0996                                     const std::vector<float>& ry,
0997                                     const std::vector<float>& sx,
0998                                     const std::vector<float>& sy) {
0999   nTECW3RecHits = rx.size();
1000   TECW3RecHits.resize(nTECW3RecHits);
1001   for (int i = 0; i < nTECW3RecHits; ++i) {
1002     TECW3RecHits[i].RX = rx[i];
1003     TECW3RecHits[i].RY = ry[i];
1004     TECW3RecHits[i].SX = sx[i];
1005     TECW3RecHits[i].SY = sy[i];
1006   }
1007 
1008   return;
1009 }
1010 
1011 void PGlobalRecHit::putTECW4RecHits(const std::vector<float>& rx,
1012                                     const std::vector<float>& ry,
1013                                     const std::vector<float>& sx,
1014                                     const std::vector<float>& sy) {
1015   nTECW4RecHits = rx.size();
1016   TECW4RecHits.resize(nTECW4RecHits);
1017   for (int i = 0; i < nTECW4RecHits; ++i) {
1018     TECW4RecHits[i].RX = rx[i];
1019     TECW4RecHits[i].RY = ry[i];
1020     TECW4RecHits[i].SX = sx[i];
1021     TECW4RecHits[i].SY = sy[i];
1022   }
1023 
1024   return;
1025 }
1026 
1027 void PGlobalRecHit::putTECW5RecHits(const std::vector<float>& rx,
1028                                     const std::vector<float>& ry,
1029                                     const std::vector<float>& sx,
1030                                     const std::vector<float>& sy) {
1031   nTECW5RecHits = rx.size();
1032   TECW5RecHits.resize(nTECW5RecHits);
1033   for (int i = 0; i < nTECW5RecHits; ++i) {
1034     TECW5RecHits[i].RX = rx[i];
1035     TECW5RecHits[i].RY = ry[i];
1036     TECW5RecHits[i].SX = sx[i];
1037     TECW5RecHits[i].SY = sy[i];
1038   }
1039 
1040   return;
1041 }
1042 
1043 void PGlobalRecHit::putTECW6RecHits(const std::vector<float>& rx,
1044                                     const std::vector<float>& ry,
1045                                     const std::vector<float>& sx,
1046                                     const std::vector<float>& sy) {
1047   nTECW6RecHits = rx.size();
1048   TECW6RecHits.resize(nTECW6RecHits);
1049   for (int i = 0; i < nTECW6RecHits; ++i) {
1050     TECW6RecHits[i].RX = rx[i];
1051     TECW6RecHits[i].RY = ry[i];
1052     TECW6RecHits[i].SX = sx[i];
1053     TECW6RecHits[i].SY = sy[i];
1054   }
1055 
1056   return;
1057 }
1058 
1059 void PGlobalRecHit::putTECW7RecHits(const std::vector<float>& rx,
1060                                     const std::vector<float>& ry,
1061                                     const std::vector<float>& sx,
1062                                     const std::vector<float>& sy) {
1063   nTECW7RecHits = rx.size();
1064   TECW7RecHits.resize(nTECW7RecHits);
1065   for (int i = 0; i < nTECW7RecHits; ++i) {
1066     TECW7RecHits[i].RX = rx[i];
1067     TECW7RecHits[i].RY = ry[i];
1068     TECW7RecHits[i].SX = sx[i];
1069     TECW7RecHits[i].SY = sy[i];
1070   }
1071 
1072   return;
1073 }
1074 
1075 void PGlobalRecHit::putTECW8RecHits(const std::vector<float>& rx,
1076                                     const std::vector<float>& ry,
1077                                     const std::vector<float>& sx,
1078                                     const std::vector<float>& sy) {
1079   nTECW8RecHits = rx.size();
1080   TECW8RecHits.resize(nTECW8RecHits);
1081   for (int i = 0; i < nTECW8RecHits; ++i) {
1082     TECW8RecHits[i].RX = rx[i];
1083     TECW8RecHits[i].RY = ry[i];
1084     TECW8RecHits[i].SX = sx[i];
1085     TECW8RecHits[i].SY = sy[i];
1086   }
1087 
1088   return;
1089 }
1090 
1091 void PGlobalRecHit::putBRL1RecHits(const std::vector<float>& rx,
1092                                    const std::vector<float>& ry,
1093                                    const std::vector<float>& sx,
1094                                    const std::vector<float>& sy) {
1095   nBRL1RecHits = rx.size();
1096   BRL1RecHits.resize(nBRL1RecHits);
1097   for (int i = 0; i < nBRL1RecHits; ++i) {
1098     BRL1RecHits[i].RX = rx[i];
1099     BRL1RecHits[i].RY = ry[i];
1100     BRL1RecHits[i].SX = sx[i];
1101     BRL1RecHits[i].SY = sy[i];
1102   }
1103 
1104   return;
1105 }
1106 
1107 void PGlobalRecHit::putBRL2RecHits(const std::vector<float>& rx,
1108                                    const std::vector<float>& ry,
1109                                    const std::vector<float>& sx,
1110                                    const std::vector<float>& sy) {
1111   nBRL2RecHits = rx.size();
1112   BRL2RecHits.resize(nBRL2RecHits);
1113   for (int i = 0; i < nBRL2RecHits; ++i) {
1114     BRL2RecHits[i].RX = rx[i];
1115     BRL2RecHits[i].RY = ry[i];
1116     BRL2RecHits[i].SX = sx[i];
1117     BRL2RecHits[i].SY = sy[i];
1118   }
1119 
1120   return;
1121 }
1122 
1123 void PGlobalRecHit::putBRL3RecHits(const std::vector<float>& rx,
1124                                    const std::vector<float>& ry,
1125                                    const std::vector<float>& sx,
1126                                    const std::vector<float>& sy) {
1127   nBRL3RecHits = rx.size();
1128   BRL3RecHits.resize(nBRL3RecHits);
1129   for (int i = 0; i < nBRL3RecHits; ++i) {
1130     BRL3RecHits[i].RX = rx[i];
1131     BRL3RecHits[i].RY = ry[i];
1132     BRL3RecHits[i].SX = sx[i];
1133     BRL3RecHits[i].SY = sy[i];
1134   }
1135 
1136   return;
1137 }
1138 
1139 void PGlobalRecHit::putFWD1pRecHits(const std::vector<float>& rx,
1140                                     const std::vector<float>& ry,
1141                                     const std::vector<float>& sx,
1142                                     const std::vector<float>& sy) {
1143   nFWD1pRecHits = rx.size();
1144   FWD1pRecHits.resize(nFWD1pRecHits);
1145   for (int i = 0; i < nFWD1pRecHits; ++i) {
1146     FWD1pRecHits[i].RX = rx[i];
1147     FWD1pRecHits[i].RY = ry[i];
1148     FWD1pRecHits[i].SX = sx[i];
1149     FWD1pRecHits[i].SY = sy[i];
1150   }
1151 
1152   return;
1153 }
1154 
1155 void PGlobalRecHit::putFWD1nRecHits(const std::vector<float>& rx,
1156                                     const std::vector<float>& ry,
1157                                     const std::vector<float>& sx,
1158                                     const std::vector<float>& sy) {
1159   nFWD1nRecHits = rx.size();
1160   FWD1nRecHits.resize(nFWD1nRecHits);
1161   for (int i = 0; i < nFWD1nRecHits; ++i) {
1162     FWD1nRecHits[i].RX = rx[i];
1163     FWD1nRecHits[i].RY = ry[i];
1164     FWD1nRecHits[i].SX = sx[i];
1165     FWD1nRecHits[i].SY = sy[i];
1166   }
1167 
1168   return;
1169 }
1170 
1171 void PGlobalRecHit::putFWD2pRecHits(const std::vector<float>& rx,
1172                                     const std::vector<float>& ry,
1173                                     const std::vector<float>& sx,
1174                                     const std::vector<float>& sy) {
1175   nFWD2pRecHits = rx.size();
1176   FWD2pRecHits.resize(nFWD2pRecHits);
1177   for (int i = 0; i < nFWD2pRecHits; ++i) {
1178     FWD2pRecHits[i].RX = rx[i];
1179     FWD2pRecHits[i].RY = ry[i];
1180     FWD2pRecHits[i].SX = sx[i];
1181     FWD2pRecHits[i].SY = sy[i];
1182   }
1183 
1184   return;
1185 }
1186 
1187 void PGlobalRecHit::putFWD2nRecHits(const std::vector<float>& rx,
1188                                     const std::vector<float>& ry,
1189                                     const std::vector<float>& sx,
1190                                     const std::vector<float>& sy) {
1191   nFWD2nRecHits = rx.size();
1192   FWD2nRecHits.resize(nFWD2nRecHits);
1193   for (int i = 0; i < nFWD2nRecHits; ++i) {
1194     FWD2nRecHits[i].RX = rx[i];
1195     FWD2nRecHits[i].RY = ry[i];
1196     FWD2nRecHits[i].SX = sx[i];
1197     FWD2nRecHits[i].SY = sy[i];
1198   }
1199 
1200   return;
1201 }
1202 
1203 void PGlobalRecHit::putDTRecHits(const std::vector<float>& rhd, const std::vector<float>& shd) {
1204   nDTRecHits = rhd.size();
1205   DTRecHits.resize(nDTRecHits);
1206   for (int i = 0; i < nDTRecHits; ++i) {
1207     DTRecHits[i].RHD = rhd[i];
1208     DTRecHits[i].SHD = shd[i];
1209   }
1210 
1211   return;
1212 }
1213 
1214 void PGlobalRecHit::putCSCRecHits(const std::vector<float>& rhphi,
1215                                   const std::vector<float>& rhperp,
1216                                   const std::vector<float>& shphi) {
1217   nCSCRecHits = rhphi.size();
1218   CSCRecHits.resize(nCSCRecHits);
1219   for (int i = 0; i < nCSCRecHits; ++i) {
1220     CSCRecHits[i].RHPHI = rhphi[i];
1221     CSCRecHits[i].RHPERP = rhperp[i];
1222     CSCRecHits[i].SHPHI = shphi[i];
1223   }
1224 
1225   return;
1226 }
1227 
1228 void PGlobalRecHit::putRPCRecHits(const std::vector<float>& rhx, const std::vector<float>& shx) {
1229   nRPCRecHits = rhx.size();
1230   RPCRecHits.resize(nRPCRecHits);
1231   for (int i = 0; i < nRPCRecHits; ++i) {
1232     RPCRecHits[i].RHX = rhx[i];
1233     RPCRecHits[i].SHX = shx[i];
1234   }
1235 
1236   return;
1237 }
1238 
1239 ///////////////////////////////////////////////////////////////////////////////
1240 // PHcalValidInfoJets
1241 ///////////////////////////////////////////////////////////////////////////////
1242 
1243 void PHcalValidInfoJets::fillTProfileJet(double e, double r, double t) {
1244   jetHite.push_back((float)e);
1245   jetHitr.push_back((float)r);
1246   jetHitt.push_back((float)t);
1247   nJetHit++;
1248 
1249   //  std::cout << " fillTProfileJet - nJetHit = " << nJetHit << std::endl;
1250 }
1251 
1252 void PHcalValidInfoJets::fillEcollectJet(double ee, double he, double hoe, double etot) {
1253   // hardest jet properties
1254 
1255   ecalJet = (float)ee;
1256   hcalJet = (float)he;
1257   hoJet = (float)hoe;
1258   etotJet = (float)etot;
1259 }
1260 
1261 void PHcalValidInfoJets::fillEtaPhiProfileJet(double eta0, double phi0, double eta, double phi, double dist) {
1262   detaJet = (float)(eta - eta0);
1263   dphiJet = (float)(phi - phi0);
1264   drJet = (float)dist;
1265 }
1266 
1267 void PHcalValidInfoJets::fillJets(const std::vector<double>& en,
1268                                   const std::vector<double>& eta,
1269                                   const std::vector<double>& phi) {
1270   nJet = en.size();
1271   for (int i = 0; i < nJet; i++) {
1272     jetE.push_back((float)en[i]);
1273     jetEta.push_back((float)eta[i]);
1274     jetPhi.push_back((float)phi[i]);
1275   }
1276 
1277   //  std::cout << " fillJets - nJet = " << nJet << std::endl;
1278 }
1279 
1280 void PHcalValidInfoJets::fillDiJets(double mass) { dijetM = (float)mass; }
1281 
1282 ///////////////////////////////////////////////////////////////////////////////
1283 // PHcalValidInfoLayer
1284 ///////////////////////////////////////////////////////////////////////////////
1285 
1286 void PHcalValidInfoLayer::fillLayers(double el[], double ed[], double ho, double hbhe, double ebee) {
1287   for (int i = 0; i < 20; i++) {
1288     double en = 0.001 * el[i];  // GeV
1289     eLayer.push_back((float)en);
1290   }
1291   for (int i = 0; i < 4; i++) {
1292     double en = 0.001 * ed[i];  // GeV
1293     eDepth.push_back((float)en);
1294   }
1295   eHO = (float)ho;
1296   eHBHE = (float)hbhe;  // MeV
1297   eEBEE = (float)ebee;
1298 }
1299 
1300 void PHcalValidInfoLayer::fillHF(double fibl, double fibs, double enec, double enhc) {
1301   elongHF = (float)fibl;
1302   eshortHF = (float)fibs;
1303   eEcalHF = (float)enec;
1304   eHcalHF = (float)enhc;
1305 }
1306 
1307 void PHcalValidInfoLayer::fillHits(int nHits, int lay, int unitID, double eta, double phi, double ehit, double t) {
1308   hitLayer.push_back((float)lay);
1309   hitId.push_back((float)unitID);
1310   hitEta.push_back((float)eta);
1311   hitPhi.push_back((float)phi);
1312   hitE.push_back((float)ehit);
1313   hitTime.push_back((float)t);
1314   hitN++;
1315 
1316   //  std::cout << " fillHits: nHits,hitN = " << nHits << "," << hitN << std::endl;
1317 }
1318 
1319 ///////////////////////////////////////////////////////////////////////////////
1320 // PHcalValidInfoNxN
1321 ///////////////////////////////////////////////////////////////////////////////
1322 
1323 void PHcalValidInfoNxN::fillHvsE(double ee, double he, double hoe, double etot) {
1324   ecalNxNr = (float)ee;
1325   hcalNxNr = (float)he;
1326   hoNxNr = (float)hoe;
1327   etotNxNr = (float)etot;
1328 }
1329 
1330 void PHcalValidInfoNxN::fillEcollectNxN(double een, double hen, double hoen, double etotn) {
1331   ecalNxN = (float)een;
1332   hcalNxN = (float)hen;
1333   hoNxN = (float)hoen;
1334   etotNxN = (float)etotn;
1335 }
1336 
1337 void PHcalValidInfoNxN::fillTProfileNxN(double e, int i, double t) {
1338   idNxN.push_back((float)i);
1339   eNxN.push_back((float)e);
1340   tNxN.push_back((float)t);
1341   nNxN++;
1342 
1343   //  std::cout << " fillTProfileNxN - nNxN = " << nNxN << std::endl;
1344 }
1345 
1346 ///////////////////////////////////////////////////////////////////////////////
1347 // PMuonSimHit
1348 ///////////////////////////////////////////////////////////////////////////////
1349 
1350 void PMuonSimHit::putRawGenPart(int n) {
1351   nRawGenPart = n;
1352   return;
1353 }
1354 
1355 void PMuonSimHit::putG4Vtx(const std::vector<float>& x, const std::vector<float>& y, const std::vector<float>& z) {
1356   nG4Vtx = x.size();
1357   G4Vtx.resize(nG4Vtx);
1358   for (int i = 0; i < nG4Vtx; ++i) {
1359     G4Vtx[i].x = x[i];
1360     G4Vtx[i].y = y[i];
1361     G4Vtx[i].z = z[i];
1362   }
1363   return;
1364 }
1365 
1366 void PMuonSimHit::putG4Trk(const std::vector<float>& pt,
1367                            const std::vector<float>& e,
1368                            const std::vector<float>& eta,
1369                            const std::vector<float>& phi) {
1370   nG4Trk = pt.size();
1371   G4Trk.resize(nG4Trk);
1372   for (int i = 0; i < nG4Trk; ++i) {
1373     G4Trk[i].pt = pt[i];
1374     G4Trk[i].e = e[i];
1375     G4Trk[i].eta = eta[i];
1376     G4Trk[i].phi = phi[i];
1377   }
1378   return;
1379 }
1380 
1381 void PMuonSimHit::putCSCHits(const std::vector<int>& _cscId,
1382                              const std::vector<unsigned int>& _detUnitId,
1383                              const std::vector<float>& _trackId,
1384                              const std::vector<float>& _processType,
1385                              const std::vector<float>& _particleType,
1386                              const std::vector<float>& _pabs,
1387                              const std::vector<float>& _globposz,
1388                              const std::vector<float>& _globposphi,
1389                              const std::vector<float>& _globposeta,
1390                              const std::vector<float>& _locposx,
1391                              const std::vector<float>& _locposy,
1392                              const std::vector<float>& _locposz,
1393                              const std::vector<float>& _locdirx,
1394                              const std::vector<float>& _locdiry,
1395                              const std::vector<float>& _locdirz,
1396                              const std::vector<float>& _locdirtheta,
1397                              const std::vector<float>& _locdirphi,
1398                              const std::vector<float>& _exitpointx,
1399                              const std::vector<float>& _exitpointy,
1400                              const std::vector<float>& _exitpointz,
1401                              const std::vector<float>& _entrypointx,
1402                              const std::vector<float>& _entrypointy,
1403                              const std::vector<float>& _entrypointz,
1404                              const std::vector<float>& _enloss,
1405                              const std::vector<float>& _tof)
1406 
1407 {
1408   nCSCHits = _tof.size();
1409   CSCHits.resize(nCSCHits);
1410   for (int i = 0; i < nCSCHits; ++i) {
1411     CSCHits[i]._cscId = _cscId[i];
1412     CSCHits[i]._detUnitId = _detUnitId[i];
1413     CSCHits[i]._trackId = _trackId[i];
1414     CSCHits[i]._processType = _processType[i];
1415     CSCHits[i]._particleType = _particleType[i];
1416     CSCHits[i]._pabs = _pabs[i];
1417     CSCHits[i]._globposz = _globposz[i];
1418     CSCHits[i]._globposphi = _globposphi[i];
1419     CSCHits[i]._globposeta = _globposeta[i];
1420     CSCHits[i]._locposx = _locposx[i];
1421     CSCHits[i]._locposy = _locposy[i];
1422     CSCHits[i]._locposz = _locposz[i];
1423     CSCHits[i]._locdirx = _locdirx[i];
1424     CSCHits[i]._locdiry = _locdiry[i];
1425     CSCHits[i]._locdirz = _locdirz[i];
1426     CSCHits[i]._locdirtheta = _locdirtheta[i];
1427     CSCHits[i]._locdirphi = _locdirphi[i];
1428     CSCHits[i]._exitpointx = _exitpointx[i];
1429     CSCHits[i]._exitpointy = _exitpointy[i];
1430     CSCHits[i]._exitpointz = _exitpointz[i];
1431     CSCHits[i]._entrypointx = _entrypointx[i];
1432     CSCHits[i]._entrypointy = _entrypointy[i];
1433     CSCHits[i]._entrypointz = _entrypointz[i];
1434     CSCHits[i]._enloss = _enloss[i];
1435     CSCHits[i]._tof = _tof[i];
1436   }
1437   return;
1438 }
1439 
1440 void PMuonSimHit::putDTHits(const std::vector<unsigned int>& _detUnitId,
1441                             const std::vector<float>& _trackId,
1442                             const std::vector<float>& _processType,
1443                             const std::vector<float>& _particleType,
1444                             const std::vector<float>& _pabs,
1445                             const std::vector<float>& _globposz,
1446                             const std::vector<float>& _globposphi,
1447                             const std::vector<float>& _globposeta,
1448                             const std::vector<float>& _locposx,
1449                             const std::vector<float>& _locposy,
1450                             const std::vector<float>& _locposz,
1451                             const std::vector<float>& _locdirx,
1452                             const std::vector<float>& _locdiry,
1453                             const std::vector<float>& _locdirz,
1454                             const std::vector<float>& _locdirtheta,
1455                             const std::vector<float>& _locdirphi,
1456                             const std::vector<float>& _exitpointx,
1457                             const std::vector<float>& _exitpointy,
1458                             const std::vector<float>& _exitpointz,
1459                             const std::vector<float>& _entrypointx,
1460                             const std::vector<float>& _entrypointy,
1461                             const std::vector<float>& _entrypointz,
1462                             const std::vector<float>& _enloss,
1463                             const std::vector<float>& _tof)
1464 
1465 {
1466   nDTHits = _tof.size();
1467   DTHits.resize(nDTHits);
1468   for (int i = 0; i < nDTHits; ++i) {
1469     DTHits[i]._detUnitId = _detUnitId[i];
1470     DTHits[i]._trackId = _trackId[i];
1471     DTHits[i]._processType = _processType[i];
1472     DTHits[i]._particleType = _particleType[i];
1473     DTHits[i]._pabs = _pabs[i];
1474     DTHits[i]._globposz = _globposz[i];
1475     DTHits[i]._globposphi = _globposphi[i];
1476     DTHits[i]._globposeta = _globposeta[i];
1477     DTHits[i]._locposx = _locposx[i];
1478     DTHits[i]._locposy = _locposy[i];
1479     DTHits[i]._locposz = _locposz[i];
1480     DTHits[i]._locdirx = _locdirx[i];
1481     DTHits[i]._locdiry = _locdiry[i];
1482     DTHits[i]._locdirz = _locdirz[i];
1483     DTHits[i]._locdirtheta = _locdirtheta[i];
1484     DTHits[i]._locdirphi = _locdirphi[i];
1485     DTHits[i]._exitpointx = _exitpointx[i];
1486     DTHits[i]._exitpointy = _exitpointy[i];
1487     DTHits[i]._exitpointz = _exitpointz[i];
1488     DTHits[i]._entrypointx = _entrypointx[i];
1489     DTHits[i]._entrypointy = _entrypointy[i];
1490     DTHits[i]._entrypointz = _entrypointz[i];
1491     DTHits[i]._enloss = _enloss[i];
1492     DTHits[i]._tof = _tof[i];
1493   }
1494   return;
1495 }
1496 
1497 void PMuonSimHit::putRPCHits(const std::vector<unsigned int>& _detUnitId,
1498                              const std::vector<float>& _trackId,
1499                              const std::vector<float>& _processType,
1500                              const std::vector<float>& _particleType,
1501                              const std::vector<float>& _pabs,
1502                              const std::vector<float>& _globposz,
1503                              const std::vector<float>& _globposphi,
1504                              const std::vector<float>& _globposeta,
1505                              const std::vector<float>& _locposx,
1506                              const std::vector<float>& _locposy,
1507                              const std::vector<float>& _locposz,
1508                              const std::vector<float>& _locdirx,
1509                              const std::vector<float>& _locdiry,
1510                              const std::vector<float>& _locdirz,
1511                              const std::vector<float>& _locdirtheta,
1512                              const std::vector<float>& _locdirphi,
1513                              const std::vector<float>& _exitpointx,
1514                              const std::vector<float>& _exitpointy,
1515                              const std::vector<float>& _exitpointz,
1516                              const std::vector<float>& _entrypointx,
1517                              const std::vector<float>& _entrypointy,
1518                              const std::vector<float>& _entrypointz,
1519                              const std::vector<float>& _enloss,
1520                              const std::vector<float>& _tof)
1521 
1522 {
1523   nRPCHits = _tof.size();
1524   RPCHits.resize(nRPCHits);
1525   for (int i = 0; i < nRPCHits; ++i) {
1526     RPCHits[i]._detUnitId = _detUnitId[i];
1527     RPCHits[i]._trackId = _trackId[i];
1528     RPCHits[i]._processType = _processType[i];
1529     RPCHits[i]._particleType = _particleType[i];
1530     RPCHits[i]._pabs = _pabs[i];
1531     RPCHits[i]._globposz = _globposz[i];
1532     RPCHits[i]._globposphi = _globposphi[i];
1533     RPCHits[i]._globposeta = _globposeta[i];
1534     RPCHits[i]._locposx = _locposx[i];
1535     RPCHits[i]._locposy = _locposy[i];
1536     RPCHits[i]._locposz = _locposz[i];
1537     RPCHits[i]._locdirx = _locdirx[i];
1538     RPCHits[i]._locdiry = _locdiry[i];
1539     RPCHits[i]._locdirz = _locdirz[i];
1540     RPCHits[i]._locdirtheta = _locdirtheta[i];
1541     RPCHits[i]._locdirphi = _locdirphi[i];
1542     RPCHits[i]._exitpointx = _exitpointx[i];
1543     RPCHits[i]._exitpointy = _exitpointy[i];
1544     RPCHits[i]._exitpointz = _exitpointz[i];
1545     RPCHits[i]._entrypointx = _entrypointx[i];
1546     RPCHits[i]._entrypointy = _entrypointy[i];
1547     RPCHits[i]._entrypointz = _entrypointz[i];
1548     RPCHits[i]._enloss = _enloss[i];
1549     RPCHits[i]._tof = _tof[i];
1550   }
1551   return;
1552 }
1553 
1554 ///////////////////////////////////////////////////////////////////////////////
1555 // PTrackerSimHit
1556 ///////////////////////////////////////////////////////////////////////////////
1557 
1558 void PTrackerSimHit::putRawGenPart(int n) {
1559   nRawGenPart = n;
1560   return;
1561 }
1562 
1563 void PTrackerSimHit::putG4Vtx(const std::vector<float>& x, const std::vector<float>& y, const std::vector<float>& z) {
1564   nG4Vtx = x.size();
1565   G4Vtx.resize(nG4Vtx);
1566   for (int i = 0; i < nG4Vtx; ++i) {
1567     G4Vtx[i].x = x[i];
1568     G4Vtx[i].y = y[i];
1569     G4Vtx[i].z = z[i];
1570   }
1571 
1572   return;
1573 }
1574 
1575 void PTrackerSimHit::putG4Trk(const std::vector<float>& pt,
1576                               const std::vector<float>& e,
1577                               const std::vector<float>& eta,
1578                               const std::vector<float>& phi) {
1579   nG4Trk = pt.size();
1580   G4Trk.resize(nG4Trk);
1581   for (int i = 0; i < nG4Trk; ++i) {
1582     G4Trk[i].pt = pt[i];
1583     G4Trk[i].e = e[i];
1584     G4Trk[i].eta = eta[i];
1585     G4Trk[i].phi = phi[i];
1586   }
1587 
1588   return;
1589 }
1590 
1591 void PTrackerSimHit::putHits(const std::vector<int>& _sysID,
1592                              const std::vector<float>& _detUnitId,
1593                              const std::vector<float>& _trackId,
1594                              const std::vector<float>& _processType,
1595                              const std::vector<float>& _particleType,
1596                              const std::vector<float>& _pabs,
1597                              const std::vector<float>& _lpx,
1598                              const std::vector<float>& _lpy,
1599                              const std::vector<float>& _lpz,
1600                              const std::vector<float>& _ldx,
1601                              const std::vector<float>& _ldy,
1602                              const std::vector<float>& _ldz,
1603                              const std::vector<float>& _ldtheta,
1604                              const std::vector<float>& _ldphi,
1605                              const std::vector<float>& _exx,
1606                              const std::vector<float>& _exy,
1607                              const std::vector<float>& _exz,
1608                              const std::vector<float>& _enx,
1609                              const std::vector<float>& _eny,
1610                              const std::vector<float>& _enz,
1611                              const std::vector<float>& _eloss,
1612                              const std::vector<float>& _tof)
1613 
1614 {
1615   nHits = _tof.size();
1616   Hits.resize(nHits);
1617   for (int i = 0; i < nHits; ++i) {
1618     Hits[i]._sysID = _sysID[i];
1619     Hits[i]._detUnitId = _detUnitId[i];
1620     Hits[i]._trackId = _trackId[i];
1621     Hits[i]._processType = _processType[i];
1622     Hits[i]._particleType = _particleType[i];
1623     Hits[i]._pabs = _pabs[i];
1624     Hits[i]._lpx = _lpx[i];
1625     Hits[i]._lpy = _lpy[i];
1626     Hits[i]._lpz = _lpz[i];
1627     Hits[i]._ldx = _ldx[i];
1628     Hits[i]._ldy = _ldy[i];
1629     Hits[i]._ldz = _ldz[i];
1630     Hits[i]._ldtheta = _ldtheta[i];
1631     Hits[i]._ldphi = _ldphi[i];
1632     Hits[i]._exx = _exx[i];
1633     Hits[i]._exy = _exy[i];
1634     Hits[i]._exz = _exz[i];
1635     Hits[i]._enx = _enx[i];
1636     Hits[i]._eny = _eny[i];
1637     Hits[i]._enz = _enz[i];
1638     Hits[i]._eloss = _eloss[i];
1639     Hits[i]._tof = _tof[i];
1640   }
1641 
1642   return;
1643 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!