File indexing completed on 2026-09-19 08:35:05
0001 #include "Calib.h"
0002 #include <iostream>
0003 #include <fstream>
0004 #include "TMath.h"
0005 #include "TString.h"
0006 #include "TObjArray.h"
0007 #include "TObjString.h"
0008 #include <utility>
0009
0010 ClassImp(Calib);
0011
0012
0013
0014
0015 double Calib::GetPedestalMeanH(int cellID) const{
0016
0017
0018 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0019 if(it!=CaloCalib.end()) return it->second.PedestalMeanH;
0020 else return 9999;
0021 }
0022
0023 double Calib::GetPedestalMeanL(int cellID) const{
0024
0025
0026 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0027 if(it!=CaloCalib.end()) return it->second.PedestalMeanL;
0028 else return 9999;
0029 }
0030
0031 double Calib::GetPedestalSigH(int cellID) const{
0032
0033
0034 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0035 if(it!=CaloCalib.end()) return it->second.PedestalSigH;
0036 else return 9999;
0037 }
0038 double Calib::GetPedestalSigL(int cellID) const{
0039
0040
0041 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0042 if(it!=CaloCalib.end()) return it->second.PedestalSigL;
0043 else return 9999;
0044 }
0045
0046 double Calib::GetScaleHigh(int cellID)const {
0047 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0048 if(it!=CaloCalib.end()){
0049 if (it->second.ScaleH != -1000 && (BCcalc && it->second.BadChannel > 1)){
0050 return it->second.ScaleH;
0051 } else {
0052 return GetAverageScaleHigh();
0053 }
0054 } else return -1.;
0055 }
0056
0057 double Calib::GetScaleHighPerSingleLayer(int cellID)const {
0058 Setup* setup = Setup::GetInstance();
0059 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0060 if(it!=CaloCalib.end()){
0061 if (it->second.ScaleH != -1000 && (BCcalc && it->second.BadChannel > 1)){
0062 return it->second.ScaleH/setup->GetLayersInSegment(cellID);
0063 } else {
0064 return GetAverageScaleHighPerSingleLayer();
0065 }
0066 } else return -1.;
0067 }
0068
0069 double Calib::GetScaleWidthHigh(int cellID)const {
0070
0071
0072 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0073 if(it!=CaloCalib.end()) return it->second.ScaleWidthH;
0074 else return -1.;
0075 }
0076
0077 double Calib::GetCalcScaleLow(int cellID) const {
0078 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0079 if(it!=CaloCalib.end()){
0080 if (it->second.ScaleH != -1000 && it->second.LGHGCorr != -64 && (BCcalc && it->second.BadChannel > 1)){
0081 return (it->second.ScaleH)/it->second.LGHGCorr;
0082 } else if ( it->second.LGHGCorr != -64 && (BCcalc && it->second.BadChannel > 1)){
0083 return (GetAverageScaleHigh())/it->second.LGHGCorr;
0084 } else if (it->second.ScaleH != -1000 && (BCcalc && it->second.BadChannel > 1)){
0085 return (it->second.ScaleH)/GetAverageLGHGCorr();
0086 } else {
0087 return (GetAverageScaleHigh())/GetAverageLGHGCorr();
0088 }
0089 }
0090
0091
0092
0093
0094
0095
0096
0097
0098
0099
0100
0101 else return -1.;
0102 }
0103
0104 double Calib::GetScaleLow(int cellID) const {
0105 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0106 if(it!=CaloCalib.end()) return it->second.ScaleL;
0107 else return -1.;
0108 }
0109
0110 double Calib::GetScaleWidthLow(int cellID) const {
0111 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0112 if(it!=CaloCalib.end()) return it->second.ScaleWidthL;
0113 else return -1.;
0114 }
0115
0116 double Calib::GetLGHGCorr(int cellID) const {
0117 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0118 if(it!=CaloCalib.end()) return it->second.LGHGCorr;
0119 else return -1.;
0120 }
0121
0122 double Calib::GetLGHGCorrOff(int cellID) const {
0123 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0124 if(it!=CaloCalib.end()) return it->second.LGHGCorrOff;
0125 else return -1.;
0126 }
0127
0128 double Calib::GetHGLGCorr(int cellID) const {
0129 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0130 if(it!=CaloCalib.end()) return it->second.HGLGCorr;
0131 else return -1.;
0132 }
0133
0134 double Calib::GetHGLGCorrOff(int cellID) const {
0135 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0136 if(it!=CaloCalib.end()) return it->second.HGLGCorrOff;
0137 else return -1.;
0138 }
0139
0140 short Calib::GetBadChannel(int cellID) const {
0141 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0142 if(it!=CaloCalib.end()) return it->second.BadChannel;
0143 else return -1.;
0144 }
0145
0146 double Calib::GetToAOff(int cellID) const {
0147 std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0148 if(it!=CaloCalib.end()) return it->second.HGLGCorrOff;
0149 else return -1.;
0150 }
0151
0152
0153
0154
0155
0156 double Calib::GetPedestalMeanH(int row, int col, int lay, int mod=0) const{
0157 Setup* setup = Setup::GetInstance();
0158 int key=setup->GetCellID(row, col, lay, mod);
0159 return GetPedestalMeanH(key);
0160 }
0161
0162 double Calib::GetPedestalMeanL(int row, int col, int lay, int mod=0) const{
0163 Setup* setup = Setup::GetInstance();
0164 int key=setup->GetCellID(row, col, lay, mod);
0165 return GetPedestalMeanL(key);
0166 }
0167
0168 double Calib::GetPedestalSigH(int row, int col, int lay, int mod=0) const{
0169 Setup* setup = Setup::GetInstance();
0170 int key=setup->GetCellID(row, col, lay, mod);
0171 return GetPedestalSigH(key);
0172 }
0173
0174 double Calib::GetPedestalSigL(int row, int col, int lay, int mod=0) const{
0175 Setup* setup = Setup::GetInstance();
0176 int key=setup->GetCellID(row, col, lay, mod);
0177 return GetPedestalSigL(key);
0178 }
0179
0180 double Calib::GetScaleHigh(int row, int col, int lay, int mod=0)const{
0181 Setup* setup = Setup::GetInstance();
0182 int key=setup->GetCellID(row, col,lay,mod);
0183 return GetScaleHigh(key);
0184 }
0185
0186 double Calib::GetScaleHighPerSingleLayer(int row, int col, int lay, int mod=0)const{
0187 Setup* setup = Setup::GetInstance();
0188 int key=setup->GetCellID(row, col,lay,mod);
0189 return GetScaleHighPerSingleLayer(key);
0190 }
0191
0192
0193 double Calib::GetScaleWidthHigh(int row, int col, int lay, int mod=0)const{
0194 Setup* setup = Setup::GetInstance();
0195 int key=setup->GetCellID(row, col,lay,mod);
0196 return GetScaleWidthHigh(key);
0197 }
0198
0199 double Calib::GetScaleLow(int row, int col, int lay, int mod=0)const{
0200 Setup* setup = Setup::GetInstance();
0201 int key=setup->GetCellID(row, col, lay, mod);
0202 return GetScaleLow(key);
0203 }
0204
0205 double Calib::GetCalcScaleLow(int row, int col, int lay, int mod=0)const{
0206 Setup* setup = Setup::GetInstance();
0207 int key=setup->GetCellID(row, col, lay, mod);
0208 return GetCalcScaleLow(key);
0209 }
0210
0211 double Calib::GetScaleWidthLow(int row, int col, int lay, int mod=0)const{
0212 Setup* setup = Setup::GetInstance();
0213 int key=setup->GetCellID(row, col, lay, mod);
0214 return GetScaleWidthLow(key);
0215 }
0216
0217 double Calib::GetLGHGCorr(int row, int col, int lay, int mod=0)const{
0218 Setup* setup = Setup::GetInstance();
0219 int key=setup->GetCellID(row, col, lay, mod);
0220 return GetLGHGCorr(key);
0221 }
0222
0223 double Calib::GetLGHGCorrOff(int row, int col, int lay, int mod=0)const{
0224 Setup* setup = Setup::GetInstance();
0225 int key=setup->GetCellID(row, col, lay, mod);
0226 return GetLGHGCorrOff(key);
0227 }
0228
0229 double Calib::GetHGLGCorr(int row, int col, int lay, int mod=0)const{
0230 Setup* setup = Setup::GetInstance();
0231 int key=setup->GetCellID(row, col, lay, mod);
0232 return GetHGLGCorr(key);
0233 }
0234
0235 double Calib::GetHGLGCorrOff(int row, int col, int lay, int mod=0)const{
0236 Setup* setup = Setup::GetInstance();
0237 int key=setup->GetCellID(row, col, lay, mod);
0238 return GetHGLGCorrOff(key);
0239 }
0240
0241 short Calib::GetBadChannel(int row, int col, int lay, int mod=0)const{
0242 Setup* setup = Setup::GetInstance();
0243 int key=setup->GetCellID(row, col, lay, mod);
0244 return GetBadChannel(key);
0245 }
0246
0247 double Calib::GetToAOff(int row, int col, int lay, int mod=0)const{
0248 Setup* setup = Setup::GetInstance();
0249 int key=setup->GetCellID(row, col, lay, mod);
0250 return GetToAOff(key);
0251 }
0252
0253
0254
0255
0256
0257 double Calib::GetAveragePedestalMeanHigh()const{
0258 double avSc = 0;
0259 int notCalib = 0;
0260 std::map<int, TileCalib>::const_iterator it;
0261 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0262 if (it->second.PedestalMeanH == -1000)
0263 notCalib++;
0264 else
0265 avSc += it->second.PedestalMeanH;
0266 }
0267 return avSc/(CaloCalib.size()-notCalib);
0268 }
0269
0270 double Calib::GetAveragePedestalSigHigh()const{
0271 double avSc = 0;
0272 int notCalib = 0;
0273 std::map<int, TileCalib>::const_iterator it;
0274 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0275 if (it->second.PedestalSigH == -1000)
0276 notCalib++;
0277 else
0278 avSc += it->second.PedestalSigH;
0279 }
0280 return avSc/(CaloCalib.size()-notCalib);
0281 }
0282
0283 double Calib::GetAveragePedestalMeanLow()const{
0284 double avSc = 0;
0285 int notCalib = 0;
0286 std::map<int, TileCalib>::const_iterator it;
0287 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0288 if (it->second.PedestalMeanL == -1000)
0289 notCalib++;
0290 else
0291 avSc += it->second.PedestalMeanL;
0292 }
0293 return avSc/(CaloCalib.size()-notCalib);
0294 }
0295
0296 double Calib::GetAveragePedestalSigLow()const{
0297 double avSc = 0;
0298 int notCalib = 0;
0299 std::map<int, TileCalib>::const_iterator it;
0300 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0301 if (it->second.PedestalSigL == -1000)
0302 notCalib++;
0303 else
0304 avSc += it->second.PedestalSigL;
0305 }
0306 return avSc/(CaloCalib.size()-notCalib);
0307 }
0308
0309
0310 double Calib::GetAverageScaleHigh( )const{
0311 double avSc = 0;
0312 int notCalib = 0;
0313 std::map<int, TileCalib>::const_iterator it;
0314 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0315 if (it->second.ScaleH == -1000 || (BCcalc && it->second.BadChannel < 2) ){
0316 notCalib++;
0317 } else {
0318 avSc += it->second.ScaleH;
0319 }
0320 }
0321 double avScaleR = -10000;
0322 if (avSc != 0. && (CaloCalib.size()-notCalib) != 0)
0323 avScaleR = avSc/(CaloCalib.size()-notCalib);
0324 return avScaleR;
0325 }
0326
0327
0328 double Calib::GetAverageScaleHigh(int &active )const{
0329 double avSc = 0;
0330 int notCalib = 0;
0331 std::map<int, TileCalib>::const_iterator it;
0332 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0333 if (it->second.ScaleH == -1000 || (BCcalc && it->second.BadChannel < 2) ){
0334 notCalib++;
0335 } else {
0336 avSc += it->second.ScaleH;
0337 }
0338 }
0339 active=(CaloCalib.size()-notCalib);
0340 double avScaleR = -10000;
0341 if (avSc != 0. && active > 0)
0342 avScaleR = avSc/active;
0343 return avScaleR;
0344 }
0345
0346 double Calib::GetAverageScaleHighPerSingleLayer( )const{
0347 double avSc = 0;
0348 int notCalib = 0;
0349 Setup* setup = Setup::GetInstance();
0350 std::map<int, TileCalib>::const_iterator it;
0351 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0352 if (it->second.ScaleH == -1000 || (BCcalc && it->second.BadChannel < 2) ){
0353 notCalib++;
0354 } else {
0355 avSc += it->second.ScaleH/setup->GetLayersInSegment(it->first);
0356 }
0357 }
0358 int active = (CaloCalib.size()-notCalib);
0359 double avScaleR = -10000;
0360 if (avSc != 0. && active > 0)
0361 avScaleR = avSc/active;
0362 return avScaleR;
0363 }
0364
0365
0366 double Calib::GetAverageScaleHighPerSingleLayer(int &active, double &avTilesPerLayer )const{
0367 double avSc = 0;
0368 int notCalib = 0;
0369 avTilesPerLayer = 0.;
0370 Setup* setup = Setup::GetInstance();
0371 std::map<int, TileCalib>::const_iterator it;
0372 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0373 if (it->second.ScaleH == -1000 || (BCcalc && it->second.BadChannel < 2) ){
0374 notCalib++;
0375 } else {
0376 avSc += it->second.ScaleH/setup->GetLayersInSegment(it->first);
0377 avTilesPerLayer +=setup->GetLayersInSegment(it->first);
0378 }
0379 }
0380 active=(CaloCalib.size()-notCalib);
0381 double avScaleR = -10000;
0382 if (avSc != 0. && active > 0){
0383 avScaleR = avSc/active;
0384 avTilesPerLayer=avTilesPerLayer/active;
0385 } else {
0386 avTilesPerLayer= -10000;
0387 }
0388 return avScaleR;
0389 }
0390
0391 double Calib::GetAverageScaleWidthHigh()const{
0392 double avSc = 0;
0393 int notCalib = 0;
0394 std::map<int, TileCalib>::const_iterator it;
0395 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0396 if (it->second.ScaleWidthH == -1000 || (BCcalc && it->second.BadChannel < 2) ){
0397 notCalib++;
0398 } else {
0399 avSc += it->second.ScaleWidthH;
0400 }
0401 }
0402 int active = (CaloCalib.size()-notCalib);
0403 double avScaleR = -10000;
0404 if (avSc != 0. && active > 0)
0405 avScaleR = avSc/active;
0406 return avScaleR;
0407 }
0408
0409 double Calib::GetAverageScaleLow()const{
0410 double avSc = 0;
0411 int notCalib = 0;
0412 std::map<int, TileCalib>::const_iterator it;
0413 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0414 if (it->second.ScaleL == -1000 || (BCcalc && it->second.BadChannel < 2) ){
0415 notCalib++;
0416 } else {
0417 avSc += it->second.ScaleL;
0418 }
0419 }
0420 int active = (CaloCalib.size()-notCalib);
0421 double avScaleR = -10000;
0422 if (avSc != 0. && active > 0)
0423 avScaleR = avSc/active;
0424 return avScaleR;
0425 }
0426 double Calib::GetAverageScaleWidthLow()const{
0427 double avSc = 0;
0428 int notCalib = 0;
0429 std::map<int, TileCalib>::const_iterator it;
0430 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0431 if (it->second.ScaleWidthL == -1000 || (BCcalc && it->second.BadChannel < 2) ){
0432 notCalib++;
0433 } else {
0434 avSc += it->second.ScaleWidthL;
0435 }
0436 }
0437 int active = (CaloCalib.size()-notCalib);
0438 double avScaleR = -10000;
0439 if (avSc != 0. && active > 0)
0440 avScaleR = avSc/active;
0441 return avScaleR;
0442 }
0443
0444 double Calib::GetAverageLGHGCorr()const{
0445 double avSc = 0;
0446 int notCalib = 0;
0447 std::map<int, TileCalib>::const_iterator it;
0448 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0449 if (it->second.LGHGCorr == -64. || (BCcalc && it->second.BadChannel < 2) ){
0450 notCalib++;
0451 } else {
0452 avSc += it->second.LGHGCorr;
0453 }
0454 }
0455 return avSc/(CaloCalib.size()-notCalib);
0456 }
0457
0458 double Calib::GetAverageLGHGCorrOff()const{
0459 double avSc = 0;
0460 int notCalib = 0;
0461 std::map<int, TileCalib>::const_iterator it;
0462 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0463 if (it->second.LGHGCorrOff == -1000. || (BCcalc && it->second.BadChannel < 2) ){
0464 notCalib++;
0465 } else {
0466 avSc += it->second.LGHGCorrOff;
0467 }
0468 }
0469 return avSc/(CaloCalib.size()-notCalib);
0470 }
0471
0472 double Calib::GetAverageHGLGCorr()const{
0473 double avSc = 0;
0474 int notCalib = 0;
0475 std::map<int, TileCalib>::const_iterator it;
0476 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0477 if (it->second.HGLGCorr == -64. || (BCcalc && it->second.BadChannel < 2) ){
0478 notCalib++;
0479 } else {
0480 avSc += it->second.HGLGCorr;
0481 }
0482 }
0483 return avSc/(CaloCalib.size()-notCalib);
0484 }
0485
0486 double Calib::GetAverageHGLGCorrOff()const{
0487 double avSc = 0;
0488 int notCalib = 0;
0489 std::map<int, TileCalib>::const_iterator it;
0490 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0491 if (it->second.HGLGCorrOff == -1000. || (BCcalc && it->second.BadChannel < 2) ){
0492 notCalib++;
0493 } else {
0494 avSc += it->second.HGLGCorrOff;
0495 }
0496 }
0497 return avSc/(CaloCalib.size()-notCalib);
0498 }
0499
0500
0501 int Calib::GetNumberOfChannelsWithBCflag( short bcflag )const{
0502 int nCh = 0;
0503 std::map<int, TileCalib>::const_iterator it;
0504 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0505 if (bcflag == it->second.BadChannel)
0506 nCh++;
0507 }
0508 return nCh;
0509 }
0510
0511
0512
0513
0514
0515
0516 TileCalib* Calib::GetTileCalib(int cellID){
0517 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0518 if(it!=CaloCalib.end()){
0519 return &(it->second);
0520 }
0521 else {
0522 TileCalib acal;
0523 CaloCalib[cellID]=acal;
0524 return &(CaloCalib[cellID]);
0525 }
0526 }
0527
0528 TileCalib* Calib::GetTileCalib(int row, int col, int lay, int mod=0){
0529 Setup* setup = Setup::GetInstance();
0530 int key=setup->GetCellID(row, col, lay, mod);
0531 return GetTileCalib(key);
0532 }
0533
0534
0535
0536
0537 void Calib::SetPedestalMeanH(double ped, int cellID){
0538 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0539 if(it!=CaloCalib.end()){
0540 TileCalib acal;
0541 acal.PedestalMeanH=ped;
0542 CaloCalib[cellID]=acal;
0543 }
0544 else it->second.PedestalMeanH=ped;
0545 }
0546
0547 void Calib::SetPedestalMeanL(double ped, int cellID){
0548 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0549 if(it!=CaloCalib.end()){
0550 TileCalib acal;
0551 acal.PedestalMeanL=ped;
0552 CaloCalib[cellID]=acal;
0553 }
0554 else it->second.PedestalMeanL=ped;
0555 }
0556
0557 void Calib::SetPedestalSigH(double ped, int cellID){
0558 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0559 if(it!=CaloCalib.end()){
0560 TileCalib acal;
0561 acal.PedestalSigH=ped;
0562 CaloCalib[cellID]=acal;
0563 }
0564 else it->second.PedestalSigH=ped;
0565 }
0566
0567 void Calib::SetPedestalSigL(double ped, int cellID){
0568 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0569 if(it!=CaloCalib.end()){
0570 TileCalib acal;
0571 acal.PedestalSigL=ped;
0572 CaloCalib[cellID]=acal;
0573 }
0574 else it->second.PedestalSigL=ped;
0575 }
0576
0577 void Calib::SetScaleHigh(double s, int cellID){
0578 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0579 if(it!=CaloCalib.end()){
0580 TileCalib acal;
0581 acal.ScaleH=s;
0582 CaloCalib[cellID]=acal;
0583 }
0584 else it->second.ScaleH=s;
0585 }
0586
0587 void Calib::SetScaleWidthHigh(double s, int cellID){
0588 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0589 if(it!=CaloCalib.end()){
0590 TileCalib acal;
0591 acal.ScaleWidthH=s;
0592 CaloCalib[cellID]=acal;
0593 }
0594 else it->second.ScaleWidthH=s;
0595 }
0596
0597 void Calib::SetScaleLow(double s, int cellID){
0598 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0599 if(it!=CaloCalib.end()){
0600 TileCalib acal;
0601 acal.ScaleL=s;
0602 CaloCalib[cellID]=acal;
0603 }
0604 else it->second.ScaleL=s;
0605 }
0606
0607 void Calib::SetScaleWidthLow(double s, int cellID){
0608 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0609 if(it!=CaloCalib.end()){
0610 TileCalib acal;
0611 acal.ScaleWidthL=s;
0612 CaloCalib[cellID]=acal;
0613 }
0614 else it->second.ScaleWidthL=s;
0615 }
0616
0617 void Calib::SetLGHGCorr(double s, int cellID){
0618 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0619 if(it!=CaloCalib.end()){
0620 TileCalib acal;
0621 acal.LGHGCorr=s;
0622 CaloCalib[cellID]=acal;
0623 }
0624 else it->second.LGHGCorr=s;
0625 }
0626
0627 void Calib::SetLGHGCorrOff(double s, int cellID){
0628 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0629 if(it!=CaloCalib.end()){
0630 TileCalib acal;
0631 acal.LGHGCorrOff=s;
0632 CaloCalib[cellID]=acal;
0633 }
0634 else it->second.LGHGCorrOff=s;
0635 }
0636
0637 void Calib::SetHGLGCorr(double s, int cellID){
0638 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0639 if(it!=CaloCalib.end()){
0640 TileCalib acal;
0641 acal.HGLGCorr=s;
0642 CaloCalib[cellID]=acal;
0643 }
0644 else it->second.HGLGCorr=s;
0645 }
0646
0647 void Calib::SetHGLGCorrOff(double s, int cellID){
0648 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0649 if(it!=CaloCalib.end()){
0650 TileCalib acal;
0651 acal.HGLGCorrOff=s;
0652 CaloCalib[cellID]=acal;
0653 }
0654 else it->second.HGLGCorrOff=s;
0655 }
0656
0657 void Calib::SetBadChannel(short s, int cellID){
0658 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0659 if(it!=CaloCalib.end()){
0660 TileCalib acal;
0661 acal.BadChannel=s;
0662 CaloCalib[cellID]=acal;
0663 }
0664 else it->second.BadChannel=s;
0665 }
0666
0667 void Calib::SetToAOff(double s, int cellID){
0668 std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0669 if(it!=CaloCalib.end()){
0670 TileCalib acal;
0671 acal.HGLGCorrOff=s;
0672 CaloCalib[cellID]=acal;
0673 }
0674 else it->second.HGLGCorrOff=s;
0675 }
0676
0677
0678
0679
0680
0681
0682
0683 void Calib::SetPedestalMeanH(double ped, int row, int col, int lay, int mod=0){
0684 Setup* setup = Setup::GetInstance();
0685 int key=setup->GetCellID(row,col,lay,mod);
0686 SetPedestalMeanH(ped,key);
0687 }
0688 void Calib::SetPedestalMeanL(double ped, int row, int col, int lay, int mod=0){
0689 Setup* setup = Setup::GetInstance();
0690 int key=setup->GetCellID(row,col,lay,mod);
0691 SetPedestalMeanL(ped,key);
0692 }
0693 void Calib::SetPedestalSigH(double ped, int row, int col, int lay, int mod=0){
0694 Setup* setup = Setup::GetInstance();
0695 int key=setup->GetCellID(row,col,lay,mod);
0696 SetPedestalSigH(ped,key);
0697 }
0698 void Calib::SetPedestalSigL(double ped, int row, int col, int lay, int mod=0){
0699 Setup* setup = Setup::GetInstance();
0700 int key=setup->GetCellID(row,col,lay,mod);
0701 SetPedestalSigL(ped,key);
0702 }
0703
0704 void Calib::SetScaleHigh(double s, int row, int col, int lay, int mod=0){
0705 Setup* setup = Setup::GetInstance();
0706 int key=setup->GetCellID(row,col,lay,mod);
0707 SetScaleHigh(s,key);
0708 }
0709
0710 void Calib::SetScaleWidthHigh(double s, int row, int col, int lay, int mod=0){
0711 Setup* setup = Setup::GetInstance();
0712 int key=setup->GetCellID(row,col,lay,mod);
0713 SetScaleWidthHigh(s,key);
0714 }
0715
0716 void Calib::SetScaleLow(double s, int row, int col, int lay, int mod=0){
0717 Setup* setup = Setup::GetInstance();
0718 int key=setup->GetCellID(row,col,lay,mod);
0719 SetScaleLow(s,key);
0720 }
0721
0722 void Calib::SetScaleWidthLow(double s, int row, int col, int lay, int mod=0){
0723 Setup* setup = Setup::GetInstance();
0724 int key=setup->GetCellID(row,col,lay,mod);
0725 SetScaleWidthLow(s,key);
0726 }
0727
0728 void Calib::SetLGHGCorr(double s, int row, int col, int lay, int mod=0){
0729 Setup* setup = Setup::GetInstance();
0730 int key=setup->GetCellID(row,col,lay,mod);
0731 SetLGHGCorr(s,key);
0732 }
0733
0734 void Calib::SetLGHGCorrOff(double s, int row, int col, int lay, int mod=0){
0735 Setup* setup = Setup::GetInstance();
0736 int key=setup->GetCellID(row,col,lay,mod);
0737 SetLGHGCorrOff(s,key);
0738 }
0739
0740 void Calib::SetHGLGCorr(double s, int row, int col, int lay, int mod=0){
0741 Setup* setup = Setup::GetInstance();
0742 int key=setup->GetCellID(row,col,lay,mod);
0743 SetHGLGCorr(s,key);
0744 }
0745
0746 void Calib::SetHGLGCorrOff(double s, int row, int col, int lay, int mod=0){
0747 Setup* setup = Setup::GetInstance();
0748 int key=setup->GetCellID(row,col,lay,mod);
0749 SetHGLGCorrOff(s,key);
0750 }
0751
0752 void Calib::SetBadChannel(short s, int row, int col, int lay, int mod=0){
0753 Setup* setup = Setup::GetInstance();
0754 int key=setup->GetCellID(row,col,lay,mod);
0755 SetBadChannel(s,key);
0756 }
0757
0758 void Calib::SetToAOff(double s, int row, int col, int lay, int mod=0){
0759 Setup* setup = Setup::GetInstance();
0760 int key=setup->GetCellID(row,col,lay,mod);
0761 SetToAOff(s,key);
0762 }
0763
0764
0765 bool Calib::IsLayerEnabled(int layer, int mod) const{
0766 Setup* setup = Setup::GetInstance();
0767 bool isEnabled = false;
0768 if (!BCcalc) return true;
0769 for (int r = 0; r< setup->GetNMaxRow(); r++){
0770 for (int c = 0; c < setup->GetNMaxColumn(); c++){
0771 if (mod == -1){
0772 for (int m = 0; m < setup->GetNMaxModule(); m++){
0773 int bc = GetBadChannel(r, c, layer, m);
0774 if (bc == 3 ){
0775 isEnabled = true;
0776 break;
0777 }
0778 }
0779 } else {
0780 int bc = GetBadChannel(r, c, layer, mod);
0781 if (bc == 3){
0782 isEnabled = true;
0783 break;
0784 }
0785 }
0786 }
0787 }
0788 return isEnabled;
0789 }
0790
0791
0792
0793
0794 int Calib::GetRunNumber(void){
0795 return RunNumber;
0796 }
0797
0798 int Calib::GetRunNumberPed(void){
0799 return RunNumberPed;
0800 }
0801
0802 int Calib::GetRunNumberMip(void){
0803 return RunNumberMip;
0804 }
0805
0806 const TTimeStamp* Calib::GetBeginRunTime(void) const{
0807 return &BeginRunTime;
0808 }
0809
0810 const TTimeStamp* Calib::GetBeginRunTimePed(void) const{
0811 return &BeginRunTimePed;
0812 }
0813
0814 const TTimeStamp* Calib::GetBeginRunTimeMip(void) const{
0815 return &BeginRunTimeMip;
0816 }
0817
0818 double Calib::GetVop(void){
0819 return Vop;
0820 }
0821
0822 double Calib::GetVov(void){
0823 return Vov;
0824 }
0825
0826 bool Calib::GetBCCalib(void){
0827 return BCcalc;
0828 }
0829
0830
0831
0832
0833 void Calib::SetRunNumber(int r){
0834 RunNumber=r;
0835 }
0836
0837 void Calib::SetRunNumberPed(int r){
0838 RunNumberPed=r;
0839 }
0840
0841 void Calib::SetRunNumberMip(int r){
0842 RunNumberMip=r;
0843 }
0844
0845 void Calib::SetBeginRunTime(TTimeStamp t){
0846 BeginRunTime=t;
0847 }
0848
0849 void Calib::SetBeginRunTimePed(TTimeStamp t){
0850 BeginRunTimePed=t;
0851 }
0852
0853 void Calib::SetBeginRunTimeMip(TTimeStamp t){
0854 BeginRunTimeMip=t;
0855 }
0856
0857 void Calib::SetVop(double v){
0858 Vop=v;
0859 }
0860
0861 void Calib::SetVov(double v){
0862 Vov=v;
0863 }
0864
0865 void Calib::SetBCCalib(bool b){
0866 BCcalc=b;
0867 }
0868
0869
0870 void Calib::PrintGlobalInfo(){
0871 std::cout << "********************************************************************************************************" << std::endl;
0872 std::cout << "Calib info:\n \t RunNr: " << GetRunNumber() << "\t start time:" << GetBeginRunTime()
0873 << "\n\t RunNr ped: " << GetRunNumberPed() << "\t start time:" << GetBeginRunTimePed()
0874 << "\n\t RunNr mip: " << GetRunNumberMip() << "\t start time:" << GetBeginRunTimeMip()
0875 << "\n\t Vop: " << GetVop() << "\t Vov: "<< GetVov() << "\t BC calib set: " << GetBCCalib() << std::endl;
0876 std::cout << "\n\t mean Scale: " << GetAverageScaleHigh() << std::endl;
0877 std::cout << "********************************************************************************************************" << std::endl;
0878 }
0879
0880 void Calib::PrintDetailedGlobalInfo(){
0881 std::cout << "********************************************************************************************************" << std::endl;
0882 std::cout << "Calib info:\n \t RunNr: " << GetRunNumber() << "\t start time:" << GetBeginRunTime()
0883 << "\n\t RunNr ped: " << GetRunNumberPed() << "\t start time:" << GetBeginRunTimePed()
0884 << "\n\t RunNr mip: " << GetRunNumberMip() << "\t start time:" << GetBeginRunTimeMip()
0885 << "\n\t Vop: " << GetVop() << "\t Vov: "<< GetVov() << "\t BC calib set: " << GetBCCalib()
0886 << "\n\t mean HG Scale: " << GetAverageScaleHigh() << "\t width\t" << GetAverageScaleWidthHigh()
0887 << "\n\t mean LG Scale: " << GetAverageScaleLow() << "\t width\t" << GetAverageScaleWidthLow()
0888 << "\n\t mean LG-HG a: " << GetAverageLGHGCorr() << "\t b\t" << GetAverageLGHGCorrOff()
0889 << "\n\t mean HG-LG a: " << GetAverageHGLGCorr() << "\t b\t" << GetAverageHGLGCorrOff() << std::endl;
0890 std::cout << "********************************************************************************************************" << std::endl;
0891 }
0892
0893
0894 void Calib::PrintCalibToFile(TString filename){
0895 std::fstream fFileCalibOut;
0896 std::cout << "********************************************************************************************************" << std::endl;
0897 std::cout << "Printing calib info to: " << filename.Data() << std::endl;
0898 std::cout << "********************************************************************************************************" << std::endl;
0899 fFileCalibOut.open(filename.Data(), std::ios::out);
0900 fFileCalibOut << "#****************************************************************************************************************************************************************************************************************" << std::endl;
0901 fFileCalibOut << "#Calib info:\n \t RunNr: " << GetRunNumber() << "\t start time:" << GetBeginRunTime() << "\t RunNrPed: " << GetRunNumberPed() << "\t start time:" << GetBeginRunTimePed()<< "\t RunNrMip: " << GetRunNumberMip() << "\t start time:" << GetBeginRunTimeMip()<< "\t Vop: " << GetVop() << "\t Vov: "<< GetVov() << "\t BC calib set: " << GetBCCalib() << std::endl;
0902 fFileCalibOut << "#****************************************************************************************************************************************************************************************************************" << std::endl;
0903 Setup* setup = Setup::GetInstance();
0904
0905 TString head = Form("#cellID\tlayer\trow\tcolumn\tmodule\tped mean H\tped sig H\tped mean L\tped sig L\tmip Scale H\tmip Width H\tmip Scale L\tmip Width L\tLG-HG\tHG-LG\tBC");
0906 fFileCalibOut << head.Data() << std::endl;
0907 fFileCalibOut << "#****************************************************************************************************************************************************************************************************************" << std::endl;
0908 std::map<int, TileCalib>::const_iterator it;
0909 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0910 TString outSt = "";
0911 outSt = Form("%d\t%d\t%d\t%d\t%d\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%d",
0912 it->first, setup->GetLayer(it->first), setup->GetRow(it->first), setup->GetColumn(it->first), setup->GetModule(it->first),
0913 it->second.PedestalMeanH, it->second.PedestalSigH,
0914 it->second.PedestalMeanL, it->second.PedestalSigL,
0915 it->second.ScaleH, it->second.ScaleWidthH,
0916 it->second.ScaleL, it->second.ScaleWidthL,
0917 it->second.LGHGCorr, it->second.LGHGCorrOff, it->second.HGLGCorr, it->second.HGLGCorrOff,
0918 it->second.BadChannel);
0919 fFileCalibOut << outSt.Data() << std::endl;
0920 }
0921 fFileCalibOut.close();
0922 }
0923
0924 void Calib::ReadCalibFromTextFile(TString filename, int debug){
0925
0926 std::fstream fFileCalibIn;
0927 std::cout << "********************************************************************************************************" << std::endl;
0928 std::cout << "Reading calib info from: " << filename.Data() << std::endl;
0929 std::cout << "********************************************************************************************************" << std::endl;
0930 fFileCalibIn.open(filename.Data(), std::ios::in);
0931 if (!fFileCalibIn) {
0932 std::cout << "ERROR: file " << filename.Data() << " not found!" << std::endl;
0933 return;
0934 }
0935 int nMod = 0;
0936 for( TString tempLine; tempLine.ReadLine(fFileCalibIn, kTRUE); ) {
0937
0938 if (tempLine.BeginsWith("%") || tempLine.BeginsWith("#")){
0939 continue;
0940 }
0941 if (debug > 0) std::cout << tempLine.Data() << std::endl;
0942
0943
0944 TObjArray *tempArr = tempLine.Tokenize("\t");
0945 if(tempArr->GetEntries()<1){
0946 if (debug > 1) std::cout << "nothing to be done" << std::endl;
0947 delete tempArr;
0948 continue;
0949 } else if (tempArr->GetEntries() == 1 ){
0950
0951 tempArr = tempLine.Tokenize(" ");
0952 if(tempArr->GetEntries()<1){
0953 if (debug > 1) std::cout << "nothing to be done" << std::endl;
0954 delete tempArr;
0955 continue;
0956 } else if (tempArr->GetEntries() == 1 ) {
0957 if (debug > 1) std::cout << ((TString)((TObjString*)tempArr->At(0))->GetString()).Data() << " no correct format detected" << std::endl;
0958 delete tempArr;
0959 continue;
0960 }
0961 }
0962 if (tempArr->GetEntries() == 9){
0963 std::cout << tempLine.Data() << std::endl;
0964 TString part = ((TObjString*)tempArr->At(0))->GetString();
0965 TObjArray *tempArr2 = part.Tokenize(" ");
0966 int runNr = ((TString)((TObjString*)tempArr2->At(1))->GetString()).Atoi();
0967 if (GetRunNumber() != runNr){
0968 if (debug > 0) std::cout << "Resetting run number: " << runNr << std::endl;
0969 SetRunNumber(runNr);
0970 nMod++;
0971 }
0972 delete tempArr2;
0973
0974 part = ((TObjString*)tempArr->At(2))->GetString();
0975 TObjArray *tempArr6 = part.Tokenize(" ");
0976 int runNrPed = ((TString)((TObjString*)tempArr6->At(1))->GetString()).Atoi();
0977 if (GetRunNumberPed() != runNrPed){
0978 if (debug > 0) std::cout << "Resetting run number pedestal: " << runNrPed << std::endl;
0979 SetRunNumberPed(runNrPed);
0980 nMod++;
0981 }
0982 delete tempArr6;
0983
0984 part = ((TObjString*)tempArr->At(4))->GetString();
0985 TObjArray *tempArr5 = part.Tokenize(" ");
0986 int runNrMip = ((TString)((TObjString*)tempArr5->At(1))->GetString()).Atoi();
0987 if (GetRunNumberMip() != runNrMip){
0988 if (debug > 0) std::cout << "Resetting run number mip: " << runNrMip << std::endl;
0989 SetRunNumberMip(runNrMip);
0990 nMod++;
0991 }
0992 delete tempArr5;
0993
0994 part = ((TObjString*)tempArr->At(6))->GetString();
0995 TObjArray *tempArr3 = part.Tokenize(" ");
0996 double vop = ((TString)((TObjString*)tempArr3->At(1))->GetString()).Atof();
0997 if (TMath::Abs(GetVop() - vop) > 1e-2){
0998 if (debug > 0) std::cout << "Resetting Vop: " << vop << std::endl;
0999 SetVop(vop);
1000 nMod++;
1001 }
1002 delete tempArr3;
1003
1004 part = ((TObjString*)tempArr->At(7))->GetString();
1005 TObjArray *tempArr4 = part.Tokenize(" ");
1006 double vov = ((TString)((TObjString*)tempArr4->At(1))->GetString()).Atof();
1007 if (TMath::Abs(GetVov() - vov) > 1e-2){
1008 if (debug > 0) std::cout << "Resetting Vov: " << vov << std::endl;
1009 SetVop(vov);
1010 nMod++;
1011 }
1012 delete tempArr4;
1013
1014 continue;
1015 } else if (tempArr->GetEntries() != 18){
1016 std::cout << "Temp array has " << tempArr->GetEntries() << " entries"<< std::endl;
1017 std::cout << tempLine.Data() << std::endl;
1018 std::cout << "line has wrong format, should be" << std::endl;
1019 TString head = Form("#cellID\tlayer\trow\tcolumn\tmodule\tped mean H\tped sig H\tped mean L\tped sig L\tmip Scale H\tmip Width H\tmip Scale L\tmip Width L\tLG-HG\tHG-LG\tBC");
1020 std::cout << head.Data() << std::endl;
1021 delete tempArr;
1022 continue;
1023 }
1024 int cellID = ((TString)((TObjString*)tempArr->At(0))->GetString()).Atoi();
1025 int layer = ((TString)((TObjString*)tempArr->At(1))->GetString()).Atoi();
1026 int row = ((TString)((TObjString*)tempArr->At(2))->GetString()).Atoi();
1027 int column = ((TString)((TObjString*)tempArr->At(3))->GetString()).Atoi();
1028 int moduleNr = ((TString)((TObjString*)tempArr->At(4))->GetString()).Atoi();
1029 double pedMH = ((TString)((TObjString*)tempArr->At(5))->GetString()).Atof();
1030 double pedSH = ((TString)((TObjString*)tempArr->At(6))->GetString()).Atof();
1031 double pedML = ((TString)((TObjString*)tempArr->At(7))->GetString()).Atof();
1032 double pedSL = ((TString)((TObjString*)tempArr->At(8))->GetString()).Atof();
1033 double ScaleH = ((TString)((TObjString*)tempArr->At(9))->GetString()).Atof();
1034 double ScaleHW = ((TString)((TObjString*)tempArr->At(10))->GetString()).Atof();
1035 double ScaleL = ((TString)((TObjString*)tempArr->At(11))->GetString()).Atof();
1036 double ScaleLW = ((TString)((TObjString*)tempArr->At(12))->GetString()).Atof();
1037 double LGHG = ((TString)((TObjString*)tempArr->At(13))->GetString()).Atof();
1038 double LGHGOff = ((TString)((TObjString*)tempArr->At(14))->GetString()).Atof();
1039 double HGLG = ((TString)((TObjString*)tempArr->At(15))->GetString()).Atof();
1040 double HGLGOff = ((TString)((TObjString*)tempArr->At(16))->GetString()).Atof();
1041 short bc = ((TString)((TObjString*)tempArr->At(17))->GetString()).Atoi();
1042
1043 if (debug > 0) std::cout << "checking need for reset for CellID: " << cellID << "\t" << layer << "\t" << row << "\t" << column << "\t" << moduleNr << std::endl;
1044 TileCalib* tileCal = GetTileCalib(cellID);
1045 if ( TMath::Abs(pedMH - tileCal->PedestalMeanH) > 1e-4){
1046 if (debug > 1) std::cout << "resetting ped mean HG" << tileCal->PedestalMeanH << "\t" << pedMH << std::endl;
1047 tileCal->PedestalMeanH = pedMH;
1048 nMod++;
1049 }
1050 if (TMath::Abs(pedML - tileCal->PedestalMeanL) > 1e-4){
1051 if (debug > 1) std::cout << "resetting ped mean LG" << tileCal->PedestalMeanL << "\t" << pedML << std::endl;
1052 tileCal->PedestalMeanL = pedML;
1053 nMod++;
1054 }
1055 if (TMath::Abs(pedSH - tileCal->PedestalSigH) > 1e-4){
1056 if (debug > 1) std::cout << "resetting ped sig HG" << tileCal->PedestalSigH << "\t" << pedSH << std::endl;
1057 tileCal->PedestalSigH = pedSH;
1058 nMod++;
1059 }
1060 if (TMath::Abs(pedSL - tileCal->PedestalSigL) > 1e-4){
1061 if (debug > 1) std::cout << "resetting ped sig LG" << tileCal->PedestalMeanH << "\t" << pedSL << std::endl;
1062 tileCal->PedestalSigL = pedSL;
1063 nMod++;
1064 }
1065 if (TMath::Abs(ScaleH - tileCal->ScaleH ) > 1e-4){
1066 if (debug > 1) std::cout << "resetting scale HG" << tileCal->ScaleH << "\t" << ScaleH << std::endl;
1067 tileCal->ScaleH = ScaleH;
1068 nMod++;
1069 }
1070 if (TMath::Abs(ScaleHW - tileCal->ScaleWidthH) > 1e-4){
1071 if (debug > 1) std::cout << "resetting scale width HG" << tileCal->ScaleWidthH << "\t" << ScaleHW << std::endl;
1072 tileCal->ScaleWidthH = ScaleHW;
1073 nMod++;
1074 }
1075 if (TMath::Abs(ScaleL - tileCal->ScaleL) > 1e-4){
1076 if (debug > 1) std::cout << "resetting scale L" << tileCal->ScaleL << "\t" << ScaleL << std::endl;
1077 tileCal->ScaleL = ScaleL;
1078 nMod++;
1079 }
1080 if (TMath::Abs(ScaleLW - tileCal->ScaleWidthL) > 1e-4){
1081 if (debug > 1) std::cout << "resetting scale width LG" << tileCal->ScaleWidthL << "\t" << ScaleLW << std::endl;
1082 tileCal->ScaleWidthL = ScaleLW;
1083 nMod++;
1084 }
1085 if (TMath::Abs(LGHG - tileCal->LGHGCorr) > 1e-4){
1086 if (debug > 1) std::cout << "resetting LG-HG corr" << tileCal->LGHGCorr << "\t" << LGHG << std::endl;
1087 tileCal->LGHGCorr = LGHG;
1088 nMod++;
1089 }
1090 if (TMath::Abs(LGHGOff - tileCal->LGHGCorrOff) > 1e-4){
1091 if (debug > 1) std::cout << "resetting LG-HG corr offset" << tileCal->LGHGCorrOff << "\t" << LGHGOff << std::endl;
1092 tileCal->LGHGCorrOff = LGHGOff;
1093 nMod++;
1094 }
1095 if (TMath::Abs(HGLG - tileCal->HGLGCorr) > 1e-5){
1096 if (debug > 1) std::cout << "resetting HG-LG corr" << tileCal->HGLGCorr << "\t" << HGLG << std::endl;
1097 tileCal->HGLGCorr = HGLG;
1098 nMod++;
1099 }
1100 if (TMath::Abs(HGLGOff - tileCal->HGLGCorrOff) > 1e-5){
1101 if (debug > 1) std::cout << "resetting HG-LG corr offset" << tileCal->HGLGCorrOff << "\t" << HGLGOff << std::endl;
1102 tileCal->HGLGCorrOff = HGLGOff;
1103 nMod++;
1104 }
1105 if (bc != tileCal->BadChannel){
1106 if (debug > 1) std::cout << "resetting bad channel" << tileCal->BadChannel << "\t" << bc << std::endl;
1107 tileCal->BadChannel = bc;
1108 nMod++;
1109 }
1110 delete tempArr;
1111 }
1112
1113 std::map<int, TileCalib>::const_iterator it;
1114 bool allBC =true;
1115 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
1116 if (it->second.BadChannel == -64) allBC = false;
1117 }
1118 if (GetBCCalib() == false && allBC == true){
1119 nMod++;
1120 SetBCCalib(true);
1121 }
1122 if (GetBCCalib() == true && allBC == false){
1123 std::cout << "At least one channel is missing the correct bad chanel value" << std::endl;
1124 }
1125 std::cout << "********************************************************************************************************" << std::endl;
1126 std::cout << "had to perform " << nMod << " modifications to calib loaded from root file." << std::endl;
1127 std::cout << "********************************************************************************************************" << std::endl;
1128 std::cout << "done reading input calib" << std::endl;
1129 std::cout << "********************************************************************************************************" << std::endl;
1130
1131
1132 }
1133
1134
1135 void Calib::ReadExternalBadChannelMap(TString filename, int debug){
1136
1137 std::cout << "Reading in external mapping file" << std::endl;
1138 Setup* setup = Setup::GetInstance();
1139
1140 std::ifstream bcmapFile;
1141 bcmapFile.open(filename,std::ios_base::in);
1142 if (!bcmapFile) {
1143 std::cout << "ERROR: file " << filename.Data() << " not found!" << std::endl;
1144 return;
1145 }
1146
1147 int nBCs = 0;
1148 for( TString tempLine; tempLine.ReadLine(bcmapFile, kTRUE); ) {
1149
1150 if (tempLine.BeginsWith("%") || tempLine.BeginsWith("#")){
1151 continue;
1152 }
1153 if (debug > 1) std::cout << tempLine.Data() << std::endl;
1154
1155
1156 TObjArray *tempArr = tempLine.Tokenize(" ");
1157 if(tempArr->GetEntries()<2){
1158 if (debug > 1) std::cout << "nothing to be done" << std::endl;
1159 delete tempArr;
1160 continue;
1161 }
1162
1163 int mod = ((TString)((TObjString*)tempArr->At(0))->GetString()).Atoi();
1164 int layer = ((TString)((TObjString*)tempArr->At(1))->GetString()).Atoi();
1165 int row = ((TString)((TObjString*)tempArr->At(2))->GetString()).Atoi();
1166 int col = ((TString)((TObjString*)tempArr->At(3))->GetString()).Atoi();
1167 short bc = short(((TString)((TObjString*)tempArr->At(4))->GetString()).Atoi());
1168
1169 int cellID = setup->GetCellID( row, col, layer, mod);
1170 TileCalib* tileCal = GetTileCalib(cellID);
1171
1172 tileCal->BadChannel = bc;
1173 nBCs++;
1174
1175 if (debug > 1) std::cout << "cellID " << cellID << "\t BC status: " << bc<< std::endl;
1176 }
1177 std::cout << "registered " << nBCs << " bad channels!" << std::endl;
1178
1179 std::map<int, TileCalib>::const_iterator it;
1180 bool allBC =true;
1181 for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
1182 if (it->second.BadChannel == -64) allBC = false;
1183 }
1184 if (GetBCCalib() == false && allBC == true){
1185 SetBCCalib(true);
1186 }
1187 if (GetBCCalib() == true && allBC == false){
1188 std::cout << "At least one channel is missing the correct bad chanel value" << std::endl;
1189 }
1190 return;
1191 }
1192
1193
1194
1195
1196 void Calib::ReadExternalToAOffsets(TString filename, int debug){
1197
1198 std::cout << "Reading in ToA offset file" << std::endl;
1199 Setup* setup = Setup::GetInstance();
1200
1201 std::ifstream toaOffSetFile;
1202 toaOffSetFile.open(filename,std::ios_base::in);
1203 if (!toaOffSetFile) {
1204 std::cout << "ERROR: file " << filename.Data() << " not found!" << std::endl;
1205 return;
1206 }
1207
1208 int nToAOffsets = 0;
1209 for( TString tempLine; tempLine.ReadLine(toaOffSetFile, kTRUE); ) {
1210
1211 if (tempLine.BeginsWith("%") || tempLine.BeginsWith("#")){
1212 continue;
1213 }
1214 if (debug > 1) std::cout << tempLine.Data() << std::endl;
1215
1216
1217 TObjArray *tempArr = tempLine.Tokenize("\t");
1218
1219 if(tempArr->GetEntries()<2){
1220 if (debug > 1) std::cout << "nothing to be done" << std::endl;
1221 if (debug > 1) std::cout << tempArr->At(0) << std::endl;
1222 delete tempArr;
1223 continue;
1224 }
1225
1226 int asic = ((TString)((TObjString*)tempArr->At(0))->GetString()).Atoi();
1227 int half = ((TString)((TObjString*)tempArr->At(1))->GetString()).Atoi();
1228 int toaOff = ((TString)((TObjString*)tempArr->At(2))->GetString()).Atoi();
1229
1230 if (half == 0){
1231 for (Int_t c = 0; c< 36; c++){
1232 int cellID = setup->GetCellID( asic, c);
1233 if (cellID != -1){
1234 TileCalib* tileCal = GetTileCalib(cellID);
1235 tileCal->HGLGCorrOff = double(toaOff);
1236 if (debug > 2) std::cout << "cellID " << cellID << "\t ToA offset: " << toaOff<< std::endl;
1237 }
1238 }
1239 } else if (half == 1){
1240 for (Int_t c = 36; c< 72; c++){
1241 int cellID = setup->GetCellID( asic, c);
1242 if (cellID != -1){
1243 TileCalib* tileCal = GetTileCalib(cellID);
1244 tileCal->HGLGCorrOff = double(toaOff);
1245 if (debug > 2) std::cout << "cellID " << cellID << "\t ToA offset: " << toaOff<< std::endl;
1246 }
1247 }
1248 }
1249 nToAOffsets++;
1250
1251 }
1252 std::cout << "registered " << nToAOffsets << " different offsets!" << std::endl;
1253
1254 std::map<int, TileCalib>::const_iterator it;
1255 return;
1256 }
1257
