Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-07-13 07:54:13 

0001 #include "Calib.h"
0002 #include <iostream>
0003 #include <fstream>
0004 #include "TString.h"
0005 #include "TObjArray.h"
0006 #include "TObjString.h"
0007 #include <utility>
0008 
0009 ClassImp(Calib);
0010 
0011 //*****************************************************************************************
0012 // CALIBRATION Getters by cell ID
0013 //*****************************************************************************************
0014 double Calib::GetPedestalMeanH(int cellID) const{
0015   //std::map<int, double>::const_iterator it= PedestalMeanH.find(cellID);
0016   //if(it!=PedestalMeanH.end()) return it->second;
0017   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0018   if(it!=CaloCalib.end()) return it->second.PedestalMeanH;
0019   else return 9999;
0020 }
0021 
0022 double Calib::GetPedestalMeanL(int cellID) const{
0023   //std::map<int, double>::const_iterator it= PedestalMeanL.find(cellID);
0024   //if(it!=PedestalMeanL.end()) return it->second;
0025   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0026   if(it!=CaloCalib.end()) return it->second.PedestalMeanL;
0027   else return 9999;
0028 }
0029 
0030 double Calib::GetPedestalSigH(int cellID) const{
0031   //std::map<int, double>::const_iterator it= PedestalSigH.find(cellID);
0032   //if(it!=PedestalSigH.end()) return it->second;
0033   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0034   if(it!=CaloCalib.end()) return it->second.PedestalSigH;
0035   else return 9999;
0036 }
0037 double Calib::GetPedestalSigL(int cellID) const{
0038   //std::map<int, double>::const_iterator it= PedestalSigL.find(cellID);
0039   //if(it!=PedestalSigL.end()) return it->second;
0040   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0041   if(it!=CaloCalib.end()) return it->second.PedestalSigL;
0042   else return 9999;
0043 }
0044 
0045 double Calib::GetScaleHigh(int cellID)const {
0046   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0047   if(it!=CaloCalib.end()){
0048     if (it->second.ScaleH != -1000  && (BCcalc && it->second.BadChannel > 1)){
0049       return it->second.ScaleH;
0050     } else {
0051       return GetAverageScaleHigh();
0052     }
0053   } else return -1.;
0054 }
0055 
0056 double Calib::GetScaleWidthHigh(int cellID)const {
0057   //std::map<int, double>::const_iterator it=ScaleH.find(cellID);
0058   //if(it!=ScaleH.end()) return it->second;
0059   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0060   if(it!=CaloCalib.end()) return it->second.ScaleWidthH;
0061   else return -1.;
0062 }
0063 
0064 double Calib::GetCalcScaleLow(int cellID) const {
0065   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0066   if(it!=CaloCalib.end()){
0067     if (it->second.ScaleH != -1000 && it->second.LGHGCorr != -64  && (BCcalc && it->second.BadChannel > 1)){
0068       return it->second.ScaleH/it->second.LGHGCorr;
0069     } else if ( it->second.LGHGCorr != -64  && (BCcalc && it->second.BadChannel > 1)){
0070       return GetAverageScaleHigh()/it->second.LGHGCorr;
0071     } else if (it->second.ScaleH != -1000 && (BCcalc && it->second.BadChannel > 1)){
0072       return it->second.ScaleH/GetAverageLGHGCorr();
0073     } else {
0074       return GetAverageScaleHigh()/GetAverageLGHGCorr();
0075     }
0076   }
0077   else return -1.;
0078 }
0079 
0080 double Calib::GetScaleLow(int cellID) const {
0081   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0082   if(it!=CaloCalib.end()) return it->second.ScaleL;
0083   else return -1.;
0084 }
0085 
0086 double Calib::GetScaleWidthLow(int cellID) const {
0087   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0088   if(it!=CaloCalib.end()) return it->second.ScaleWidthL;
0089   else return -1.;
0090 }
0091 
0092 double Calib::GetLGHGCorr(int cellID) const {
0093   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0094   if(it!=CaloCalib.end()) return it->second.LGHGCorr;
0095   else return -1.;
0096 }
0097 
0098 double Calib::GetLGHGCorrOff(int cellID) const {
0099   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0100   if(it!=CaloCalib.end()) return it->second.LGHGCorrOff;
0101   else return -1.;
0102 }
0103 
0104 double Calib::GetHGLGCorr(int cellID) const {
0105   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0106   if(it!=CaloCalib.end()) return it->second.HGLGCorr;
0107   else return -1.;
0108 }
0109 
0110 double Calib::GetHGLGCorrOff(int cellID) const {
0111   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0112   if(it!=CaloCalib.end()) return it->second.HGLGCorrOff;
0113   else return -1.;
0114 }
0115 
0116 short Calib::GetBadChannel(int cellID) const {
0117   std::map<int, TileCalib>::const_iterator it= CaloCalib.find(cellID);
0118   if(it!=CaloCalib.end()) return it->second.BadChannel;
0119   else return -1.;
0120 }
0121 
0122 //*****************************************************************************************
0123 // CALIBRATION Getters by cell row, col, layer and module
0124 //*****************************************************************************************
0125 double Calib::GetPedestalMeanH(int row, int col, int lay, int mod=0) const{
0126   Setup* setup = Setup::GetInstance();
0127   int key=setup->GetCellID(row, col, lay, mod);
0128   return GetPedestalMeanH(key);
0129 }
0130 
0131 double Calib::GetPedestalMeanL(int row, int col, int lay, int mod=0) const{
0132   Setup* setup = Setup::GetInstance();
0133   int key=setup->GetCellID(row, col, lay, mod);
0134   return GetPedestalMeanL(key);
0135 }
0136 
0137 double Calib::GetPedestalSigH(int row, int col, int lay, int mod=0) const{
0138   Setup* setup = Setup::GetInstance();
0139   int key=setup->GetCellID(row, col, lay, mod);
0140   return GetPedestalSigH(key);
0141 }
0142 
0143 double Calib::GetPedestalSigL(int row, int col, int lay, int mod=0) const{
0144   Setup* setup = Setup::GetInstance();
0145   int key=setup->GetCellID(row, col, lay, mod);
0146   return GetPedestalSigL(key);
0147 }
0148 
0149 double Calib::GetScaleHigh(int row, int col, int lay, int mod=0)const{
0150   Setup* setup = Setup::GetInstance();
0151   int key=setup->GetCellID(row, col,lay,mod);
0152   return GetScaleHigh(key);
0153 }
0154 
0155 double Calib::GetScaleWidthHigh(int row, int col, int lay, int mod=0)const{
0156   Setup* setup = Setup::GetInstance();
0157   int key=setup->GetCellID(row, col,lay,mod);
0158   return GetScaleWidthHigh(key);
0159 }
0160 
0161 double Calib::GetScaleLow(int row, int col, int lay, int mod=0)const{
0162   Setup* setup = Setup::GetInstance();
0163   int key=setup->GetCellID(row, col, lay, mod);
0164   return GetScaleLow(key);
0165 }
0166 
0167 double Calib::GetCalcScaleLow(int row, int col, int lay, int mod=0)const{
0168   Setup* setup = Setup::GetInstance();
0169   int key=setup->GetCellID(row, col, lay, mod);
0170   return GetCalcScaleLow(key);
0171 }
0172 
0173 double Calib::GetScaleWidthLow(int row, int col, int lay, int mod=0)const{
0174   Setup* setup = Setup::GetInstance();
0175   int key=setup->GetCellID(row, col, lay, mod);
0176   return GetScaleWidthLow(key);
0177 }
0178 
0179 double Calib::GetLGHGCorr(int row, int col, int lay, int mod=0)const{
0180   Setup* setup = Setup::GetInstance();
0181   int key=setup->GetCellID(row, col, lay, mod);
0182   return GetLGHGCorr(key);
0183 }
0184 
0185 double Calib::GetLGHGCorrOff(int row, int col, int lay, int mod=0)const{
0186   Setup* setup = Setup::GetInstance();
0187   int key=setup->GetCellID(row, col, lay, mod);
0188   return GetLGHGCorrOff(key);
0189 }
0190 
0191 double Calib::GetHGLGCorr(int row, int col, int lay, int mod=0)const{
0192   Setup* setup = Setup::GetInstance();
0193   int key=setup->GetCellID(row, col, lay, mod);
0194   return GetHGLGCorr(key);
0195 }
0196 
0197 double Calib::GetHGLGCorrOff(int row, int col, int lay, int mod=0)const{
0198   Setup* setup = Setup::GetInstance();
0199   int key=setup->GetCellID(row, col, lay, mod);
0200   return GetHGLGCorrOff(key);
0201 }
0202 
0203 short Calib::GetBadChannel(int row, int col, int lay, int mod=0)const{
0204   Setup* setup = Setup::GetInstance();
0205   int key=setup->GetCellID(row, col, lay, mod);
0206   return GetBadChannel(key);
0207 }
0208 
0209 //*****************************************************************************************
0210 // CALIBRATION Average calculators
0211 //*****************************************************************************************
0212 double Calib::GetAveragePedestalMeanHigh()const{
0213   double avSc   = 0;
0214   int notCalib  = 0;
0215   std::map<int, TileCalib>::const_iterator it;
0216   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0217     if (it->second.PedestalMeanH == -1000)
0218       notCalib++;
0219     else 
0220       avSc += it->second.PedestalMeanH;
0221   }
0222   return avSc/(CaloCalib.size()-notCalib);
0223 }
0224 
0225 double Calib::GetAveragePedestalSigHigh()const{
0226   double avSc = 0;
0227   std::map<int, TileCalib>::const_iterator it;
0228   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0229     avSc += it->second.PedestalSigH;
0230   }
0231   return avSc/CaloCalib.size();
0232 }
0233 
0234 double Calib::GetAveragePedestalMeanLow()const{
0235   double avSc   = 0;
0236   int notCalib  = 0;
0237   std::map<int, TileCalib>::const_iterator it;
0238   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0239     if (it->second.PedestalMeanL == -1000)
0240       notCalib++;
0241     else
0242       avSc += it->second.PedestalMeanL;
0243   }
0244   return avSc/(CaloCalib.size()-notCalib);
0245 }
0246 
0247 double Calib::GetAveragePedestalSigLow()const{
0248   double avSc = 0;
0249   std::map<int, TileCalib>::const_iterator it;
0250   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0251     avSc += it->second.PedestalSigL;
0252   }
0253   return avSc/CaloCalib.size();
0254 }
0255 
0256 
0257 double Calib::GetAverageScaleHigh( )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.ScaleH == -1000 || (BCcalc && it->second.BadChannel < 2) ){
0263       notCalib++;
0264     } else {
0265       avSc += it->second.ScaleH;
0266     }
0267   }
0268   return avSc/(CaloCalib.size()-notCalib);
0269 }
0270 
0271 
0272 double Calib::GetAverageScaleHigh(int &active )const{
0273   double avSc   = 0;
0274   int notCalib  = 0;
0275   std::map<int, TileCalib>::const_iterator it;
0276   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0277     if (it->second.ScaleH == -1000 || (BCcalc && it->second.BadChannel < 2) ){
0278       notCalib++;
0279     } else {
0280       avSc += it->second.ScaleH;
0281     }
0282   }
0283   active=(CaloCalib.size()-notCalib);
0284   return avSc/(CaloCalib.size()-notCalib);
0285 }
0286 
0287 double Calib::GetAverageScaleWidthHigh()const{
0288   double avSc = 0;
0289   int notCalib  = 0;
0290   std::map<int, TileCalib>::const_iterator it;
0291   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0292     if (it->second.ScaleWidthH == -1000 || (BCcalc && it->second.BadChannel < 2) ){
0293       notCalib++;
0294     } else {
0295       avSc += it->second.ScaleWidthH;
0296     }
0297   }
0298   return avSc/(CaloCalib.size()-notCalib);
0299 }
0300 
0301 double Calib::GetAverageScaleLow()const{
0302   double avSc = 0;
0303   int notCalib  = 0;
0304   std::map<int, TileCalib>::const_iterator it;
0305   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0306     if (it->second.ScaleL == -1000 || (BCcalc && it->second.BadChannel < 2) ){
0307       notCalib++;
0308     } else {
0309       avSc += it->second.ScaleL;
0310     }
0311   }
0312   return avSc/(CaloCalib.size()-notCalib);
0313 }
0314 double Calib::GetAverageScaleWidthLow()const{
0315   double avSc = 0;
0316   int notCalib  = 0;
0317   std::map<int, TileCalib>::const_iterator it;
0318   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0319     if (it->second.ScaleWidthL == -1000 || (BCcalc && it->second.BadChannel < 2) ){
0320       notCalib++;
0321     } else {
0322       avSc += it->second.ScaleWidthL;
0323     }
0324   }
0325   return avSc/(CaloCalib.size()-notCalib);
0326 }
0327 
0328 double Calib::GetAverageLGHGCorr()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.LGHGCorr == -64. || (BCcalc && it->second.BadChannel < 2) ){
0334       notCalib++;
0335     } else {
0336       avSc += it->second.LGHGCorr;
0337     }
0338   }
0339   return avSc/(CaloCalib.size()-notCalib);
0340 }
0341 
0342 double Calib::GetAverageLGHGCorrOff()const{
0343   double avSc = 0;
0344   int notCalib  = 0;
0345   std::map<int, TileCalib>::const_iterator it;
0346   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0347     if (it->second.LGHGCorrOff == -1000. || (BCcalc && it->second.BadChannel < 2) ){
0348       notCalib++;
0349     } else {
0350       avSc += it->second.LGHGCorrOff;
0351     }
0352   }
0353   return avSc/(CaloCalib.size()-notCalib);
0354 }
0355 
0356 double Calib::GetAverageHGLGCorr()const{
0357   double avSc = 0;
0358   int notCalib  = 0;
0359   std::map<int, TileCalib>::const_iterator it;
0360   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0361     if (it->second.HGLGCorr == -64. || (BCcalc && it->second.BadChannel < 2) ){
0362       notCalib++;
0363     } else {
0364       avSc += it->second.HGLGCorr;
0365     }
0366   }
0367   return avSc/(CaloCalib.size()-notCalib);
0368 }
0369 
0370 double Calib::GetAverageHGLGCorrOff()const{
0371   double avSc = 0;
0372   int notCalib  = 0;
0373   std::map<int, TileCalib>::const_iterator it;
0374   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0375     if (it->second.HGLGCorrOff == -1000. || (BCcalc && it->second.BadChannel < 2) ){
0376       notCalib++;
0377     } else {
0378       avSc += it->second.HGLGCorrOff;
0379     }
0380   }
0381   return avSc/(CaloCalib.size()-notCalib);
0382 }
0383 
0384 
0385 int Calib::GetNumberOfChannelsWithBCflag( short bcflag )const{
0386   int nCh = 0;
0387   std::map<int, TileCalib>::const_iterator it;
0388   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0389     if (bcflag == it->second.BadChannel)
0390       nCh++;
0391   }
0392   return nCh;
0393 }
0394 
0395 
0396 //*****************************************************************************************
0397 // Getters for full calib objects
0398 //*****************************************************************************************
0399 TileCalib* Calib::GetTileCalib(int cellID){
0400   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0401   if(it!=CaloCalib.end()){
0402     return &(it->second);
0403   }
0404   else {
0405     TileCalib acal;
0406     CaloCalib[cellID]=acal;
0407     return &(CaloCalib[cellID]);
0408   }
0409 }
0410 
0411 TileCalib* Calib::GetTileCalib(int row, int col, int lay, int mod=0){
0412   Setup* setup = Setup::GetInstance();
0413   int key=setup->GetCellID(row, col, lay, mod);
0414   return GetTileCalib(key);
0415 }
0416 
0417 //*****************************************************************************************
0418 // CALIBRATION Setters by cell ID
0419 //*****************************************************************************************
0420 void Calib::SetPedestalMeanH(double ped, int cellID){
0421   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0422   if(it!=CaloCalib.end()){
0423     TileCalib acal;
0424     acal.PedestalMeanH=ped;
0425     CaloCalib[cellID]=acal;
0426   }
0427   else it->second.PedestalMeanH=ped;
0428 }
0429 
0430 void Calib::SetPedestalMeanL(double ped, int cellID){
0431   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0432   if(it!=CaloCalib.end()){
0433     TileCalib acal;
0434     acal.PedestalMeanL=ped;
0435     CaloCalib[cellID]=acal;
0436   }
0437   else it->second.PedestalMeanL=ped;
0438 }
0439 
0440 void Calib::SetPedestalSigH(double ped, int cellID){
0441   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0442   if(it!=CaloCalib.end()){
0443     TileCalib acal;
0444     acal.PedestalSigH=ped;
0445     CaloCalib[cellID]=acal;
0446   }
0447   else it->second.PedestalSigH=ped;
0448 }
0449 
0450 void Calib::SetPedestalSigL(double ped, int cellID){
0451   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0452   if(it!=CaloCalib.end()){
0453     TileCalib acal;
0454     acal.PedestalSigL=ped;
0455     CaloCalib[cellID]=acal;
0456   }
0457   else it->second.PedestalSigL=ped;
0458 }
0459 
0460 void Calib::SetScaleHigh(double s, int cellID){
0461   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0462   if(it!=CaloCalib.end()){
0463     TileCalib acal;
0464     acal.ScaleH=s;
0465     CaloCalib[cellID]=acal;
0466   }
0467   else it->second.ScaleH=s;
0468 }
0469 
0470 void Calib::SetScaleWidthHigh(double s, int cellID){
0471   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0472   if(it!=CaloCalib.end()){
0473     TileCalib acal;
0474     acal.ScaleWidthH=s;
0475     CaloCalib[cellID]=acal;
0476   }
0477   else it->second.ScaleWidthH=s;
0478 }
0479 
0480 void Calib::SetScaleLow(double s, int cellID){
0481   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0482   if(it!=CaloCalib.end()){
0483     TileCalib acal;
0484     acal.ScaleL=s;
0485     CaloCalib[cellID]=acal;
0486   }
0487   else it->second.ScaleL=s;
0488 }
0489 
0490 void Calib::SetScaleWidthLow(double s, int cellID){
0491   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0492   if(it!=CaloCalib.end()){
0493     TileCalib acal;
0494     acal.ScaleWidthL=s;
0495     CaloCalib[cellID]=acal;
0496   }
0497   else it->second.ScaleWidthL=s;
0498 }
0499 
0500 void Calib::SetLGHGCorr(double s, int cellID){
0501   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0502   if(it!=CaloCalib.end()){
0503     TileCalib acal;
0504     acal.LGHGCorr=s;
0505     CaloCalib[cellID]=acal;
0506   }
0507   else it->second.LGHGCorr=s;
0508 }
0509 
0510 void Calib::SetLGHGCorrOff(double s, int cellID){
0511   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0512   if(it!=CaloCalib.end()){
0513     TileCalib acal;
0514     acal.LGHGCorrOff=s;
0515     CaloCalib[cellID]=acal;
0516   }
0517   else it->second.LGHGCorrOff=s;
0518 }
0519 
0520 void Calib::SetHGLGCorr(double s, int cellID){
0521   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0522   if(it!=CaloCalib.end()){
0523     TileCalib acal;
0524     acal.HGLGCorr=s;
0525     CaloCalib[cellID]=acal;
0526   }
0527   else it->second.HGLGCorr=s;
0528 }
0529 
0530 void Calib::SetHGLGCorrOff(double s, int cellID){
0531   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0532   if(it!=CaloCalib.end()){
0533     TileCalib acal;
0534     acal.HGLGCorrOff=s;
0535     CaloCalib[cellID]=acal;
0536   }
0537   else it->second.HGLGCorrOff=s;
0538 }
0539 
0540 void Calib::SetBadChannel(short s, int cellID){
0541   std::map<int, TileCalib>::iterator it= CaloCalib.find(cellID);
0542   if(it!=CaloCalib.end()){
0543     TileCalib acal;
0544     acal.BadChannel=s;
0545     CaloCalib[cellID]=acal;
0546   }
0547   else it->second.BadChannel=s;
0548 }
0549 
0550 
0551 //*****************************************************************************************
0552 // CALIBRATION Setters by cell row, col, layer and module
0553 //*****************************************************************************************
0554 void Calib::SetPedestalMeanH(double ped, int row, int col, int lay, int mod=0){
0555   Setup* setup = Setup::GetInstance();
0556   int key=setup->GetCellID(row,col,lay,mod);
0557   SetPedestalMeanH(ped,key);
0558 }
0559 void Calib::SetPedestalMeanL(double ped, int row, int col, int lay, int mod=0){
0560   Setup* setup = Setup::GetInstance();
0561   int key=setup->GetCellID(row,col,lay,mod);
0562   SetPedestalMeanL(ped,key);
0563 }
0564 void Calib::SetPedestalSigH(double ped, int row, int col, int lay, int mod=0){
0565   Setup* setup = Setup::GetInstance();
0566   int key=setup->GetCellID(row,col,lay,mod);
0567   SetPedestalSigH(ped,key);
0568 }
0569 void Calib::SetPedestalSigL(double ped, int row, int col, int lay, int mod=0){
0570   Setup* setup = Setup::GetInstance();
0571   int key=setup->GetCellID(row,col,lay,mod);
0572   SetPedestalSigL(ped,key);
0573 }
0574 
0575 void Calib::SetScaleHigh(double s, int row, int col, int lay, int mod=0){
0576   Setup* setup = Setup::GetInstance();
0577   int key=setup->GetCellID(row,col,lay,mod);
0578   SetScaleHigh(s,key);
0579 }
0580 
0581 void Calib::SetScaleWidthHigh(double s, int row, int col, int lay, int mod=0){
0582   Setup* setup = Setup::GetInstance();
0583   int key=setup->GetCellID(row,col,lay,mod);
0584   SetScaleWidthHigh(s,key);
0585 }
0586 
0587 void Calib::SetScaleLow(double s, int row, int col, int lay, int mod=0){
0588   Setup* setup = Setup::GetInstance();
0589   int key=setup->GetCellID(row,col,lay,mod);
0590   SetScaleLow(s,key);
0591 }
0592 
0593 void Calib::SetScaleWidthLow(double s, int row, int col, int lay, int mod=0){
0594   Setup* setup = Setup::GetInstance();
0595   int key=setup->GetCellID(row,col,lay,mod);
0596   SetScaleWidthLow(s,key);
0597 }
0598 
0599 void Calib::SetLGHGCorr(double s, int row, int col, int lay, int mod=0){
0600   Setup* setup = Setup::GetInstance();
0601   int key=setup->GetCellID(row,col,lay,mod);
0602   SetLGHGCorr(s,key);
0603 }
0604 
0605 void Calib::SetLGHGCorrOff(double s, int row, int col, int lay, int mod=0){
0606   Setup* setup = Setup::GetInstance();
0607   int key=setup->GetCellID(row,col,lay,mod);
0608   SetLGHGCorrOff(s,key);
0609 }
0610 
0611 void Calib::SetHGLGCorr(double s, int row, int col, int lay, int mod=0){
0612   Setup* setup = Setup::GetInstance();
0613   int key=setup->GetCellID(row,col,lay,mod);
0614   SetHGLGCorr(s,key);
0615 }
0616 
0617 void Calib::SetHGLGCorrOff(double s, int row, int col, int lay, int mod=0){
0618   Setup* setup = Setup::GetInstance();
0619   int key=setup->GetCellID(row,col,lay,mod);
0620   SetHGLGCorrOff(s,key);
0621 }
0622 
0623 void Calib::SetBadChannel(short s, int row, int col, int lay, int mod=0){
0624   Setup* setup = Setup::GetInstance();
0625   int key=setup->GetCellID(row,col,lay,mod);
0626   SetBadChannel(s,key);
0627 }
0628 
0629 
0630 //*****************************************************************************************
0631 // CALIBRATION Getters for global properties
0632 //*****************************************************************************************
0633 int Calib::GetRunNumber(void){
0634   return RunNumber;
0635 }
0636 
0637 int Calib::GetRunNumberPed(void){
0638   return RunNumberPed;
0639 }
0640 
0641 int Calib::GetRunNumberMip(void){
0642   return RunNumberMip;
0643 }
0644 
0645 const TTimeStamp* Calib::GetBeginRunTime(void) const{
0646   return &BeginRunTime;
0647 }
0648 
0649 const TTimeStamp* Calib::GetBeginRunTimePed(void) const{
0650   return &BeginRunTimePed;
0651 }
0652 
0653 const TTimeStamp* Calib::GetBeginRunTimeMip(void) const{
0654   return &BeginRunTimeMip;
0655 }
0656 
0657 double Calib::GetVop(void){
0658   return Vop;
0659 }
0660 
0661 double Calib::GetVov(void){
0662   return Vov;
0663 }
0664 
0665 bool Calib::GetBCCalib(void){
0666   return BCcalc;
0667 }
0668 
0669 //*****************************************************************************************
0670 // CALIBRATION Setters for global properties
0671 //*****************************************************************************************
0672 void Calib::SetRunNumber(int r){
0673   RunNumber=r;
0674 }
0675 
0676 void Calib::SetRunNumberPed(int r){
0677   RunNumberPed=r;
0678 }
0679 
0680 void Calib::SetRunNumberMip(int r){
0681   RunNumberMip=r;
0682 }
0683 
0684 void Calib::SetBeginRunTime(TTimeStamp t){
0685   BeginRunTime=t;
0686 }
0687 
0688 void Calib::SetBeginRunTimePed(TTimeStamp t){
0689   BeginRunTimePed=t;
0690 }
0691 
0692 void Calib::SetBeginRunTimeMip(TTimeStamp t){
0693   BeginRunTimeMip=t;
0694 }
0695 
0696 void Calib::SetVop(double v){
0697   Vop=v;
0698 }
0699 
0700 void Calib::SetVov(double v){
0701   Vov=v;
0702 }
0703 
0704 void Calib::SetBCCalib(bool b){
0705   BCcalc=b;
0706 }
0707 
0708 
0709 void Calib::PrintGlobalInfo(){
0710   std::cout << "********************************************************************************************************" << std::endl;
0711   std::cout << "Calib info:\n \t RunNr: " << GetRunNumber() << "\t start time:" << GetBeginRunTime() 
0712             << "\n\t RunNr ped: " << GetRunNumberPed() << "\t start time:" << GetBeginRunTimePed() 
0713             << "\n\t RunNr mip: " << GetRunNumberMip() << "\t start time:" << GetBeginRunTimeMip() 
0714             << "\n\t Vop: " << GetVop() << "\t Vov: "<< GetVov() << "\t BC calib set: " << GetBCCalib() << std::endl;  
0715   std::cout << "********************************************************************************************************" << std::endl;
0716 }
0717 
0718 
0719 void Calib::PrintCalibToFile(TString filename){
0720   std::fstream fFileCalibOut;
0721   std::cout << "********************************************************************************************************" << std::endl;
0722   std::cout << "Printing calib info to: " << filename.Data() << std::endl;
0723   std::cout << "********************************************************************************************************" << std::endl;
0724   fFileCalibOut.open(filename.Data(), std::ios::out);
0725   fFileCalibOut << "#****************************************************************************************************************************************************************************************************************" << std::endl;
0726   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;  
0727   fFileCalibOut << "#****************************************************************************************************************************************************************************************************************" << std::endl;
0728   Setup* setup = Setup::GetInstance();
0729 
0730   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");  
0731   fFileCalibOut << head.Data() << std::endl;
0732   fFileCalibOut << "#****************************************************************************************************************************************************************************************************************" << std::endl;
0733   std::map<int, TileCalib>::const_iterator it;
0734   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0735       TString outSt = "";
0736       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",  
0737                    it->first, setup->GetLayer(it->first), setup->GetRow(it->first), setup->GetColumn(it->first), setup->GetModule(it->first), 
0738                    it->second.PedestalMeanH, it->second.PedestalSigH,
0739                    it->second.PedestalMeanL, it->second.PedestalSigL, 
0740                    it->second.ScaleH, it->second.ScaleWidthH,
0741                    it->second.ScaleL, it->second.ScaleWidthL,
0742                    it->second.LGHGCorr, it->second.LGHGCorrOff, it->second.HGLGCorr, it->second.HGLGCorrOff, 
0743                    it->second.BadChannel);
0744     fFileCalibOut << outSt.Data() << std::endl;
0745   }
0746   fFileCalibOut.close();
0747 }
0748 
0749 void Calib::ReadCalibFromTextFile(TString filename, int debug){
0750   
0751   std::fstream fFileCalibIn;
0752   std::cout << "********************************************************************************************************" << std::endl;
0753   std::cout << "Reading calib info from: " << filename.Data() << std::endl;
0754   std::cout << "********************************************************************************************************" << std::endl;
0755   fFileCalibIn.open(filename.Data(), std::ios::in);
0756   if (!fFileCalibIn) {
0757       std::cout << "ERROR: file " << filename.Data() << " not found!" << std::endl;
0758       return;
0759   }
0760   int nMod = 0;
0761   for( TString tempLine; tempLine.ReadLine(fFileCalibIn, kTRUE); ) {
0762     // check if line should be considered
0763     if (tempLine.BeginsWith("%") || tempLine.BeginsWith("#")){
0764         continue;
0765     }
0766     if (debug > 0) std::cout << tempLine.Data() << std::endl;
0767 
0768     // Separate the string according to tabulators
0769     TObjArray *tempArr  = tempLine.Tokenize("\t");
0770     if(tempArr->GetEntries()<1){
0771         if (debug > 1) std::cout << "nothing to be done" << std::endl;
0772         delete tempArr;
0773         continue;
0774     } else if (tempArr->GetEntries() == 1 ){
0775         // Separate the string according to space
0776         tempArr       = tempLine.Tokenize(" ");
0777         if(tempArr->GetEntries()<1){
0778             if (debug > 1) std::cout << "nothing to be done" << std::endl;
0779             delete tempArr;
0780             continue;
0781         } else if (tempArr->GetEntries() == 1  ) {
0782             if (debug > 1) std::cout << ((TString)((TObjString*)tempArr->At(0))->GetString()).Data() << " no correct format detected" << std::endl;
0783             delete tempArr;
0784             continue;
0785         }
0786     }
0787     if (tempArr->GetEntries() == 9){
0788      std::cout << tempLine.Data() << std::endl;
0789      TString part = ((TObjString*)tempArr->At(0))->GetString();
0790      TObjArray *tempArr2  = part.Tokenize(" ");
0791      int runNr = ((TString)((TObjString*)tempArr2->At(1))->GetString()).Atoi();
0792      if (GetRunNumber() != runNr){
0793        if (debug > 0) std::cout << "Resetting run number: " << runNr << std::endl;
0794        SetRunNumber(runNr);
0795        nMod++;
0796      }
0797      delete tempArr2;
0798      
0799      part = ((TObjString*)tempArr->At(2))->GetString();
0800      TObjArray *tempArr6  = part.Tokenize(" ");
0801      int runNrPed = ((TString)((TObjString*)tempArr6->At(1))->GetString()).Atoi();
0802      if (GetRunNumberPed() != runNrPed){
0803        if (debug > 0) std::cout << "Resetting run number pedestal: " << runNrPed << std::endl;
0804        SetRunNumberPed(runNrPed);
0805        nMod++;
0806      }
0807      delete tempArr6;
0808 
0809      part = ((TObjString*)tempArr->At(4))->GetString();
0810      TObjArray *tempArr5  = part.Tokenize(" ");
0811      int runNrMip = ((TString)((TObjString*)tempArr5->At(1))->GetString()).Atoi();
0812      if (GetRunNumberMip() != runNrMip){
0813        if (debug > 0) std::cout << "Resetting run number mip: " << runNrMip << std::endl;
0814        SetRunNumberMip(runNrMip);
0815        nMod++;
0816      }
0817      delete tempArr5;
0818      
0819      part = ((TObjString*)tempArr->At(6))->GetString();
0820      TObjArray *tempArr3  = part.Tokenize(" ");
0821      double vop = ((TString)((TObjString*)tempArr3->At(1))->GetString()).Atof();
0822      if (TMath::Abs(GetVop() - vop) > 1e-2){
0823        if (debug > 0) std::cout << "Resetting Vop: " << vop << std::endl;
0824        SetVop(vop);     
0825        nMod++;
0826      }
0827      delete tempArr3;
0828 
0829      part = ((TObjString*)tempArr->At(7))->GetString();
0830      TObjArray *tempArr4  = part.Tokenize(" ");
0831      double vov = ((TString)((TObjString*)tempArr4->At(1))->GetString()).Atof();
0832      if (TMath::Abs(GetVov() - vov) > 1e-2){
0833        if (debug > 0) std::cout << "Resetting Vov: " << vov << std::endl;
0834        SetVop(vov);     
0835        nMod++;
0836      }
0837      delete tempArr4;
0838      
0839      continue;
0840     } else if (tempArr->GetEntries() != 18){
0841       std::cout << "Temp array has " << tempArr->GetEntries() << " entries"<< std::endl;
0842       std::cout << tempLine.Data() << std::endl;
0843       std::cout << "line has wrong format, should be" << std::endl;
0844       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");  
0845       std::cout << head.Data() << std::endl;
0846       delete tempArr;
0847       continue;
0848     }
0849     int cellID      = ((TString)((TObjString*)tempArr->At(0))->GetString()).Atoi();
0850     int layer       = ((TString)((TObjString*)tempArr->At(1))->GetString()).Atoi();
0851     int row         = ((TString)((TObjString*)tempArr->At(2))->GetString()).Atoi();
0852     int column      = ((TString)((TObjString*)tempArr->At(3))->GetString()).Atoi();
0853     int moduleNr    = ((TString)((TObjString*)tempArr->At(4))->GetString()).Atoi();
0854     double pedMH    = ((TString)((TObjString*)tempArr->At(5))->GetString()).Atof();
0855     double pedSH    = ((TString)((TObjString*)tempArr->At(6))->GetString()).Atof();                       
0856     double pedML    = ((TString)((TObjString*)tempArr->At(7))->GetString()).Atof();
0857     double pedSL    = ((TString)((TObjString*)tempArr->At(8))->GetString()).Atof();                       
0858     double ScaleH   = ((TString)((TObjString*)tempArr->At(9))->GetString()).Atof();                       
0859     double ScaleHW  = ((TString)((TObjString*)tempArr->At(10))->GetString()).Atof();                       
0860     double ScaleL   = ((TString)((TObjString*)tempArr->At(11))->GetString()).Atof();                       
0861     double ScaleLW  = ((TString)((TObjString*)tempArr->At(12))->GetString()).Atof();                       
0862     double LGHG     = ((TString)((TObjString*)tempArr->At(13))->GetString()).Atof();                       
0863     double LGHGOff  = ((TString)((TObjString*)tempArr->At(14))->GetString()).Atof();                       
0864     double HGLG     = ((TString)((TObjString*)tempArr->At(15))->GetString()).Atof();                       
0865     double HGLGOff  = ((TString)((TObjString*)tempArr->At(16))->GetString()).Atof();                       
0866     short bc        = ((TString)((TObjString*)tempArr->At(17))->GetString()).Atoi();
0867       
0868     if (debug > 0) std::cout << "checking need for reset for CellID:  " << cellID << "\t" << layer << "\t" << row << "\t" << column << "\t" << moduleNr << std::endl;
0869     TileCalib* tileCal = GetTileCalib(cellID);
0870     if ( TMath::Abs(pedMH - tileCal->PedestalMeanH) > 1e-4){
0871       if (debug > 1) std::cout << "resetting ped mean HG" << tileCal->PedestalMeanH << "\t" << pedMH << std::endl;
0872       tileCal->PedestalMeanH = pedMH;
0873       nMod++;
0874     }
0875     if (TMath::Abs(pedML - tileCal->PedestalMeanL)  > 1e-4){
0876       if (debug > 1) std::cout << "resetting ped mean LG" << tileCal->PedestalMeanL << "\t" << pedML << std::endl;
0877       tileCal->PedestalMeanL = pedML;
0878       nMod++;
0879     }
0880     if (TMath::Abs(pedSH - tileCal->PedestalSigH)  > 1e-4){
0881       if (debug > 1) std::cout << "resetting ped sig HG" << tileCal->PedestalSigH << "\t" << pedSH << std::endl;
0882       tileCal->PedestalSigH = pedSH;
0883       nMod++;
0884     }
0885     if (TMath::Abs(pedSL - tileCal->PedestalSigL)  > 1e-4){
0886       if (debug > 1) std::cout << "resetting ped sig LG" << tileCal->PedestalMeanH << "\t" << pedSL << std::endl;
0887       tileCal->PedestalSigL = pedSL;
0888       nMod++;
0889     }
0890     if (TMath::Abs(ScaleH - tileCal->ScaleH )  > 1e-4){
0891       if (debug > 1) std::cout << "resetting scale HG" << tileCal->ScaleH << "\t" << ScaleH << std::endl;
0892       tileCal->ScaleH = ScaleH;
0893       nMod++;
0894     }
0895     if (TMath::Abs(ScaleHW - tileCal->ScaleWidthH)  > 1e-4){
0896       if (debug > 1) std::cout << "resetting scale width HG" << tileCal->ScaleWidthH << "\t" << ScaleHW << std::endl;
0897       tileCal->ScaleWidthH = ScaleHW;
0898       nMod++;
0899     }
0900     if (TMath::Abs(ScaleL - tileCal->ScaleL)  > 1e-4){
0901       if (debug > 1) std::cout << "resetting scale L" << tileCal->ScaleL << "\t" << ScaleL << std::endl;
0902       tileCal->ScaleL = ScaleL;
0903       nMod++;
0904     }
0905     if (TMath::Abs(ScaleLW - tileCal->ScaleWidthL)  > 1e-4){
0906       if (debug > 1) std::cout << "resetting scale width LG" << tileCal->ScaleWidthL << "\t" << ScaleLW << std::endl;
0907       tileCal->ScaleWidthL = ScaleLW;
0908       nMod++;
0909     }
0910     if (TMath::Abs(LGHG - tileCal->LGHGCorr)  > 1e-4){
0911       if (debug > 1) std::cout << "resetting LG-HG corr" << tileCal->LGHGCorr << "\t" << LGHG << std::endl;
0912       tileCal->LGHGCorr = LGHG;
0913       nMod++;
0914     }
0915     if (TMath::Abs(LGHGOff - tileCal->LGHGCorrOff)  > 1e-4){
0916       if (debug > 1) std::cout << "resetting LG-HG corr offset" << tileCal->LGHGCorrOff << "\t" << LGHGOff << std::endl;
0917       tileCal->LGHGCorrOff = LGHGOff;
0918       nMod++;
0919     }
0920     if (TMath::Abs(HGLG - tileCal->HGLGCorr)  > 1e-5){
0921       if (debug > 1) std::cout << "resetting HG-LG corr" << tileCal->HGLGCorr << "\t" << HGLG << std::endl;
0922       tileCal->HGLGCorr = HGLG;
0923       nMod++;
0924     }
0925     if (TMath::Abs(HGLGOff - tileCal->HGLGCorrOff)  > 1e-5){
0926       if (debug > 1) std::cout << "resetting HG-LG corr offset" << tileCal->HGLGCorrOff << "\t" << HGLGOff << std::endl;
0927       tileCal->HGLGCorrOff = HGLGOff;
0928       nMod++;
0929     }
0930     if (bc != tileCal->BadChannel){
0931       if (debug > 1) std::cout << "resetting bad channel" << tileCal->BadChannel << "\t" << bc << std::endl;
0932       tileCal->BadChannel = bc;
0933       nMod++;
0934     }
0935     delete tempArr;
0936   }
0937   
0938   std::map<int, TileCalib>::const_iterator it;
0939   bool allBC =true;
0940   for(it=CaloCalib.begin(); it!=CaloCalib.end(); ++it){
0941     if (it->second.BadChannel == -64) allBC = false;
0942   }
0943   if (GetBCCalib() == false && allBC == true){
0944     nMod++;
0945     SetBCCalib(true);
0946   }
0947   if (GetBCCalib() == true && allBC == false){
0948     std::cout << "At least one channel is missing the correct bad chanel value" << std::endl; 
0949   }
0950   std::cout << "********************************************************************************************************" << std::endl;
0951   std::cout << "had to perform " << nMod << " modifications to calib loaded from root file." << std::endl;
0952   std::cout << "********************************************************************************************************" << std::endl;
0953   std::cout << "done reading input calib" << std::endl;
0954   std::cout << "********************************************************************************************************" << std::endl;
0955   
0956 
0957 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!