LArCalibValidationAlg.icc

Go to the documentation of this file.

//Dear emacs, this is -*-c++-*-
/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "CaloIdentifier/CaloGain.h"
#include "CaloIdentifier/CaloCell_SuperCell_ID.h"
#include "LArIdentifier/LArOnline_SuperCellID.h"
 
template<class CONDITIONSCONTAINER, class REFCONTAINER>
LArCalibValidationAlg<CONDITIONSCONTAINER,REFCONTAINER>::LArCalibValidationAlg (const std::string& name, ISvcLocator* pSvcLocator) : 
  AthAlgorithm(name,pSvcLocator),
  m_myMsgLvl(MSG::ERROR) {
  declareProperty("ValidationKey",m_validationKey="",
          "SG key of the LArConditionsContainer to be validated");
 
  declareProperty("UseBadChannelInfo",m_useBCInfo=true,
          "Use bad-channel info to skip validation for some type of bad-channels and for channel-description");
 
  declareProperty("CheckCompletness",m_checkCompleteness=true,
          "Check if all FEBs of each COOL channel are present");
 
  declareProperty("MsgLevelForDeviations", m_myMsgLvlProp=MSG::ERROR,
          "Message Level for reporting deviations");
 
  declareProperty("ListOfDevChannels",m_chanFileName="",
          "File name to store list of deviating channels");
  declareProperty("ListOfDevFEBs",m_febFileName="",
          "File name to store list of FEBs with deviating channels");
  
  declareProperty("PatchMissingFEBs",m_patchMissingFEBs=false,
          "Patch missing FEBs using values from reference container.");
 
  declareProperty("MaxNumberMessages",m_maxmessages=2000,
          "Maximum number of messages to be printed");
 
  declareProperty("PrintFailedPattern",m_printFailedPattern=true,
          "Identifiy FEBs and Calib-lines with many deviating channels");
 
  declareProperty("DoFebAverages",m_doFebAverages=true,
          "Compare also FEB averages");
 
  declareProperty("UseCorrChannels",m_useCorrChannel=true,
          "True: Use separate correction COOL channel, False: Correction + data in the same channel");
 
}
 
template<class CONDITIONSCONTAINER,class REFCONTAINER>
LArCalibValidationAlg<CONDITIONSCONTAINER,REFCONTAINER>::~LArCalibValidationAlg() {
}
 
 
template<class CONDITIONSCONTAINER,class REFCONTAINER>
StatusCode LArCalibValidationAlg<CONDITIONSCONTAINER,REFCONTAINER>::initialize() {
  m_myMsgLvl=MSG::Level(m_myMsgLvlProp);
  if (m_patchMissingFEBs || m_patchCBs.size()) m_checkCompleteness=true;
  ATH_CHECK(m_cablingKey.initialize());
  ATH_CHECK(m_BCKey.initialize());
  ATH_CHECK(m_CLKey.initialize());
  ATH_CHECK(m_referenceKey.initialize());
  if(m_isSC) {
    m_gainMap.push_back(std::string("HG"));
  } else {  
    m_gainMap.push_back(std::string("HG"));
    m_gainMap.push_back(std::string("MG"));
    m_gainMap.push_back(std::string("LG"));
  }
  return StatusCode::SUCCESS; 
}
 
template<class CONDITIONSCONTAINER, class REFCONTAINER>
StatusCode LArCalibValidationAlg<CONDITIONSCONTAINER, REFCONTAINER>::stop() {
  ATH_MSG_INFO ( "Entering LArCalibValidationAlg/"<<name() ) ; 
 
  if(m_isSC) {
     const LArOnline_SuperCellID *onlHlp=nullptr;
     ATH_CHECK( detStore()->retrieve(onlHlp, "LArOnline_SuperCellID") );
     m_onlineHelper = dynamic_cast<const LArOnlineID_Base*>(onlHlp);
 
     const CaloCell_SuperCell_ID *cId=nullptr;
     ATH_CHECK( detStore()->retrieve(cId, "CaloCell_SuperCell_ID") );
     m_caloId=dynamic_cast<const CaloCell_Base_ID*>(cId);
  } else {   
     const LArOnlineID *onlHlp=nullptr;
     ATH_CHECK( detStore()->retrieve(onlHlp, "LArOnlineID") );
     m_onlineHelper = dynamic_cast<const LArOnlineID_Base*>(onlHlp);
 
     const CaloCell_ID *cId=nullptr;
     ATH_CHECK( detStore()->retrieve(cId, "CaloCell_ID") );
     m_caloId=dynamic_cast<const CaloCell_Base_ID*>(cId);
  }
 
  /// Get bad-channel tool 
  if (m_useBCInfo) {
    ATH_CHECK(m_bcMask.buildBitMask(m_problemsToMask,msg()));
  
  }
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  const LArOnOffIdMapping* cabling=nullptr;
  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey, ctx};
  cabling=*cablingHdl;
  if(!cabling) {
    ATH_MSG_ERROR( "Do not have cabling !" );
    return StatusCode::FAILURE;
  }
 
  SG::ReadCondHandle<LArCalibLineMapping> clHdl{m_CLKey, ctx};
  const LArCalibLineMapping *clCont {*clHdl};
  if(!clCont) {
     ATH_MSG_ERROR( "Do not have calib line mapping !!!" );
     return StatusCode::FAILURE;
  }
 
  SG::ReadCondHandle<LArBadChannelCont> readHandle{m_BCKey, ctx};
  const LArBadChannelCont *bcCont {*readHandle};
  if(!bcCont) {
      ATH_MSG_ERROR( "Do not have Bad chan container !!!" );
      return StatusCode::FAILURE;
  }
 
  /// Open files for text output
  if (m_chanFileName.size()>0) {
    m_chanFile.open(m_chanFileName.c_str());
    if (!m_chanFile.is_open()) 
      ATH_MSG_ERROR ( "Failed to open output file " << m_chanFileName << ". No output will be written." ) ;
  }
 
  if (m_febFileName.size()>0) {
    m_febFile.open(m_febFileName.c_str());
    if (!m_febFile.is_open()) 
      ATH_MSG_ERROR ( "Failed to open output file " << m_febFileName << ". No output will be written." ) ;
    else
      m_febFile << "barelEC side FT slot gain (coolChannel) : bad/total" <<std::endl;
  }
 
  // For compatibility with existing configurations, look in the detector
  // store first, then in conditions.
  m_reference=detStore()->template tryConstRetrieve<REFCONTAINER> (m_referenceKey.key());
 if (!m_reference) {
   SG::ReadCondHandle<REFCONTAINER> readHandle{m_referenceKey};
   m_reference = *readHandle;
 }
 
  /// Retrieve container to be validated
  if (m_patchMissingFEBs || m_patchCBs.size()) { //want to patch -> non-const container needed
    ATH_CHECK( detStore()->retrieve(m_nc_validation,m_validationKey) );
    m_validation=m_nc_validation;
  }
  else { //no patching -> need only non-const container
    m_nc_validation=NULL;
    ATH_CHECK( detStore()->retrieve(m_validation,m_validationKey) );
  }
  if (m_validation==m_reference) //compare pointers
    ATH_MSG_WARNING ( "The same container is used as reference!" ) ; 
 
  ATH_CHECK( preLoop() ); // Call preLoop method of derived algorithm
 
  /// Reset counters:
  m_nChecked=0;
  m_nFailedValidation=0;
  m_nValidated=0;
  m_nBad=0;
  m_nNoReference=0;
 
  unsigned maxgain;
  if(m_isSC) maxgain=CaloGain::LARMEDIUMGAIN; else maxgain=CaloGain::LARNGAIN; 
  m_checkedIds.resize(maxgain); //For the gains
 
  for (unsigned igain=CaloGain::LARHIGHGAIN; 
       igain<maxgain ; ++igain ) {
    CONTIT it=m_validation->begin(igain);
    CONTIT it_e=m_validation->end(igain);
    for (;it!=it_e;it++) {
      const HWIdentifier chid = it.channelId();
      // ignore empty or disconnected instances
      if (it->isEmpty() || !cabling->isOnlineConnected(chid)) continue; 
      ++m_nChecked;
 
      if (m_useBCInfo) {
    if (m_bcMask.cellShouldBeMasked(bcCont,chid)) {
      ATH_MSG_DEBUG ( channelDescription(chid,cabling,bcCont,igain) << " known to be bad by bad-channel tool. Ignore." ) ;
      ++m_nBad;
      continue;
    }
      }
      //ATH_MSG_INFO( "Working on " << channelDescription(chid,cabling,bcCont,gain)  );
      const LArCondObj& val=*it;
      const LArCondObj ref=getRefObj(chid,igain);
      //Check if we actually got a reference channel. 
      //If not: Consider as an error because we can't validate!
     if (ref.isEmpty()) {
       ATH_MSG_ERROR ( "Reference for " << channelDescription(chid,cabling,bcCont,igain) << " is empty!" ) ;
    //Report als missing reference as 'bad' for feb-summary
    m_checkedIds[igain].push_back(std::make_pair(chid,false));
    ++m_nNoReference;
    continue;
      }
      //Call the overloaded validation method for an individual channel
      const bool isGood=validateChannel(ref,val,chid,igain,cabling,bcCont);
      m_checkedIds[igain].push_back(std::make_pair(chid,isGood));
      if (isGood)
    ++m_nValidated;
      else {
    ++m_nFailedValidation;
      }
    }//end loop over container
    ATH_MSG_INFO("checked "<<m_checkedIds[igain].size()<<" channels for gain "<<igain);
  }//end loop over gain
 
  if (m_checkCompleteness) checkCoolChannelCompleteness(cabling, clCont, bcCont);
 
  ATH_MSG_INFO("checked completness");
 
  //call summary method
  findFailedPatterns(cabling, clCont, bcCont);
  StatusCode sc=summary(cabling, bcCont);
 
  if (m_febFile.is_open()) m_febFile.close();
  if (m_chanFile.is_open()) m_chanFile.close();
  
  //W.L 27.4.2009: Always return sucess as athena rel >=15.1.0 apparently doesn't like recoverable in finalize
  sc.ignore();
  return StatusCode::SUCCESS;
}
 
template<class CONDITIONSCONTAINER,class REFCONTAINER>
StatusCode LArCalibValidationAlg<CONDITIONSCONTAINER,REFCONTAINER>::preLoop() {
  return StatusCode::SUCCESS;
}
 
 
template<class CONDITIONSCONTAINER,class REFCONTAINER>
StatusCode LArCalibValidationAlg<CONDITIONSCONTAINER,REFCONTAINER>::summary(const LArOnOffIdMapping */*cabling*/, const LArBadChannelCont */*bcCont*/) {
 
  ATH_MSG_INFO ( "Checked " << m_nChecked << " channels from container \"" << m_validationKey 
                 << "\" against container \"" <<  m_referenceKey.key() << "\"" ) ;
 
  if (m_useBCInfo)
    ATH_MSG_INFO ( "Number of channels skipped according to masking: " << m_nBad ) ;
 
  if (m_nNoReference)
    ATH_MSG_ERROR ( "No reference found for " << m_nNoReference << " channels" ) ;
 
  if (m_nFailedValidation) 
    msg() << m_myMsgLvl << "Found " << m_nFailedValidation << " channels with calibration deviating significantly from reference" << endmsg;
 
  if (m_nNoReference==0 && m_nFailedValidation==0)
    ATH_MSG_INFO ( "All " << m_nValidated << " Channels passed the validation criteria" ) ;
  else
    ATH_MSG_INFO ( "Found " << m_nValidated << " Channels that passed the validation criteria" ) ;
  
  if (m_nFailedValidation || m_nNoReference)
    return StatusCode::RECOVERABLE;
  else
    return StatusCode::SUCCESS;
}
 
 
template<class CONDITIONSCONTAINER, class REFCONTAINER>
void LArCalibValidationAlg<CONDITIONSCONTAINER, REFCONTAINER>::findFailedPatterns(const LArOnOffIdMapping *cabling, const LArCalibLineMapping *clCont, const LArBadChannelCont *bcCont) {
  unsigned gain=0;
  std::vector<CHECKEDID_t>::const_iterator it_gain=m_checkedIds.begin();
  std::vector<CHECKEDID_t>::const_iterator it_gain_e=m_checkedIds.end();
  for (;it_gain!=it_gain_e;++it_gain,++gain) {//loop over gains
 
    //That's the data type to keep track of the number 'good' and 'bad' channels in each FEB
    //For each FEB (whose id is the key of map) we have a pair of numbers (the pair is the payload of the map)
    //The first number of the pair counts the good channes in this FEB, the second one counts the bad channels
    typedef std::map<HWIdentifier,std::pair<unsigned,unsigned> > COUNTING_t;
    COUNTING_t statiPerFEB;
    //The same thing for the calibration line...
    COUNTING_t statiPerCalibLine;
 
    CHECKEDID_t::const_iterator it_id=it_gain->begin();
    CHECKEDID_t::const_iterator it_id_e=it_gain->end();
    for (;it_id!=it_id_e;++it_id) { //loop over identifiers of suspicious channels
      const HWIdentifier chid=it_id->first;
      const bool isGood=it_id->second;
      //Fill channel status fer FEB
      const HWIdentifier febId=m_onlineHelper->feb_Id(chid);
      if (isGood)
    ++statiPerFEB[febId].first;
      else
        ++statiPerFEB[febId].second;
         
      //Fill channel status per calibLine
      const std::vector<HWIdentifier>& calibIdvec=clCont->calibSlotLine(chid);
      for (const HWIdentifier& hwid : calibIdvec) {
    if (isGood)
      ++statiPerCalibLine[hwid].first;
    else
      ++statiPerCalibLine[hwid].second;
      }
    }//end loop over identifiers of suspicious channels
    //Check fraction of failed channels per FEBs
    //Reminder: second.first -> good second.second -> bad
    
    COUNTING_t::const_iterator itFEB=statiPerFEB.begin();
    COUNTING_t::const_iterator itFEB_e=statiPerFEB.end();
    for (;itFEB!=itFEB_e;++itFEB) {
      const float badFrac=float(itFEB->second.second)/(itFEB->second.first+itFEB->second.second);
      febOutput(itFEB->first,gain, itFEB->second.first,itFEB->second.second);
      if (m_printFailedPattern && badFrac>0.2)
    msg() <<  m_myMsgLvl << channelDescription(itFEB->first,cabling,bcCont,gain,true) << " has " << badFrac*100 << "% suspicious channels" << endmsg;
    }
    
 
    /* Commented out until apparent bug in calib-line mapping EMEC special crate is fixed
    if (m_printFailedPattern) {
      //Check fraction of failed channels per calibLine
      COUNTING_t::const_iterator itCalibLine=statiPerCalibLine.begin();
      COUNTING_t::const_iterator itCalibLine_e=statiPerCalibLine.end();
      for (;itCalibLine!=itCalibLine_e;++itCalibLine) {
    if (itCalibLine->second.second>=itCalibLine->second.first) {//if at least half of the readout channels belonging to a calib-line are suspicious..
      (*m_log) << m_myMsgLvl << channelDescription(itCalibLine->first,cabling,bcCont,gain) <<": " << itCalibLine->second.second 
           << " channels out of " << itCalibLine->second.first+itCalibLine->second.second << " are suspicious." << endmsg;
    }
      }
    }
    */
  }//end loop over gains
  return;
}
 
 
template<class CONDITIONSCONTAINER, class REFCONTAINER>
void LArCalibValidationAlg<CONDITIONSCONTAINER, REFCONTAINER>::febOutput(const HWIdentifier& febid, const unsigned gain, const unsigned nGood, const unsigned nBad){
  const float frac=float(nBad)/(nGood+nBad);
  
  if (m_febFile.is_open() && nBad>0) {
    m_febFile << m_onlineHelper->barrel_ec(febid) << " " 
          << m_onlineHelper->pos_neg(febid) << " "
          << m_onlineHelper->feedthrough(febid) << " "
          << m_onlineHelper->slot(febid) << " ";
    if (gain==0) m_febFile << "H";
    else if (gain==1) m_febFile << "M";
    else if (gain==2) m_febFile << "L";
    else m_febFile << "?";
      
    m_febFile << " (" << m_validation->coolChannel(febid,gain) << ")" 
          << " : " << nBad << "/" << nGood+nBad << " ";
 
    for (unsigned i=0;i<unsigned(4*frac);i++)
      m_febFile << "*";
             
    m_febFile << std::endl;
  }
  return;
}
 
 
 
template<class CONDITIONSCONTAINER, class REFCONTAINER>
const std::string LArCalibValidationAlg<CONDITIONSCONTAINER, REFCONTAINER>::channelDescription(const HWIdentifier& chid, 
                                                                                 const LArOnOffIdMapping *cabling,
                                                                                 const LArBadChannelCont *bcCont,
                                         const unsigned gain,
                                         bool isFeb) const {
  std::ostringstream output;
 
  bool isCalib=false;
  if (!isFeb) isCalib=m_onlineHelper->isCalibration(chid);
 
  if (gain<3) 
  //  output << "Gain:"<< gain << " ";
    output << m_gainMap[gain] << " ";
  if (isFeb) 
    output << "FEB [";
  else if (isCalib)
    output << "Calib Line [";
  else 
    output << "Channel [";
  //output << " id=0x" << std::hex <<  chid.get_compact() << std::dec << " ";
  if (m_onlineHelper->barrel_ec(chid)==0) 
    output << "Bar";
  else
    output << "End";
      
  //  output << ",Side:";
  if (m_onlineHelper->pos_neg(chid)==0)
    output << ",C";
  else
    output << ",A";
 
  output << ",FT:"  << m_onlineHelper->feedthrough(chid) 
     << ",Sl:" << m_onlineHelper->slot(chid);
 
  if (isFeb) 
    output << ",CC:" << m_validation->coolChannel(chid,gain);
 
  if (!isFeb) {
    output << ",Ch:" << m_onlineHelper->channel(chid);
    if (!isCalib) {
      try {
    //if (cabling->isOnlineConnected(chid)) {
      if (m_onlineHelper->isFCALchannel(chid))
        output << ",FCAL";
      if (m_onlineHelper->isHECchannel(chid))
        output << ",HEC";
      if (m_onlineHelper->isEMBchannel(chid))
        output << ",EMB";
      if (m_onlineHelper->isEMECchannel(chid))
        output << ",EMEC";
      const Identifier id=cabling->cnvToIdentifier(chid);
      output << ",Samp:" << m_caloId->sampling(id); 
      //Could add Eta, phi....
    //}//end if is connected
    //else
    //  output << ",disconnected";
      }
      catch (LArID_Exception&) {}
    }//end if !isCalibration
  }//end if !isFeb
  output << "]"; 
 
  if (!isFeb && !isCalib && m_useBCInfo)
    if (!(bcCont->status(chid).good()))
      output << " BC [0x" << std::hex << bcCont->status(chid).packedData()<<"]" << std::dec;
  
  return output.str();
}
 
template<class CONDITIONSCONTAINER, class REFCONTAINER>
bool LArCalibValidationAlg<CONDITIONSCONTAINER, REFCONTAINER>::checkCoolChannelCompleteness(const LArOnOffIdMapping *cabling, const LArCalibLineMapping *clCont, const LArBadChannelCont *bcCont) {
  ATH_MSG_INFO("checkCoolChannelCompleteness starting....");
  bool retVal=true;
  bool retVal1=true;
  FEBANDGAIN_t missing; //Keep track of missing FEBs
  CBANDCHANANDGAIN_t missingCBs; //Keep track of missing CBs
  //typedef typename CONDITIONSCONTAINER::MultChanCollection MULTICHANCOLL;
  typedef typename CONDITIONSCONTAINER::Subset SUBSET;
  const MULTICHANCOLL* multiChanColl=m_validation; //Cast to base-class
  typename MULTICHANCOLL::const_iterator it=multiChanColl->begin();
  typename MULTICHANCOLL::const_iterator it_e=multiChanColl->end();
  unsigned subsetIndex=0;
  for (;it!=it_e;++it) {
    //const SUBSET* subset=*it;
    typename SUBSET::ConstSubsetIt febIt=(*it)->subsetBegin();
    typename SUBSET::ConstSubsetIt febIt_e=(*it)->subsetEnd();
    const unsigned gain=(*it)->gain();
    for (;febIt!=febIt_e;++febIt) {
      const HWIdentifier febId(febIt->first);
      const typename SUBSET::ChannelVector& data=febIt->second;
      ATH_MSG_DEBUG ( "Subset #" << subsetIndex << " " << channelDescription(febId,cabling, bcCont,gain,true) << " has " << data.size() << " channels" ) ;
      if (data.size()==0) {
    if (m_patchMissingFEBs) {
      ATH_MSG_WARNING ( "Found incomplete COOL channel!"
                            << channelDescription(febId,cabling, bcCont, gain,true) << " missing! Will try to patch..." ) ;
      missing.push_back(FEBANDGAIN_t::value_type(febId,gain)); //remember missing FEB/gain pair
    }
    else {
      retVal=false;
      ATH_MSG_ERROR ( "Found incomplete COOL channel! " << channelDescription(febId,cabling, bcCont, gain,true) << " missing!" ) ;
    }
      }
 
      if(m_patchCBs.size()) { // loop over channels, if connected to asked CBs
         msg()<<MSG::INFO <<" m_patchCBs.size() "<<m_patchCBs.size()<<"  ";
         for(unsigned i=0; i<m_patchCBs.size();++i) msg()<<MSG::INFO <<m_patchCBs[i]<<" ";
         msg() << endmsg;
         int chmax=128;
         if(m_isSC) chmax=320;
         for(int ch=0; ch<chmax; ++ch) {
            const HWIdentifier chanId = m_onlineHelper->channel_Id(febId,ch);
            if(! chanId.is_valid() ) {
               //ATH_MSG_INFO("Not valid HWIdentifier for channel "<<ch<<"of FEB "<<febId.get_identifier32().get_compact());
               ATH_MSG_INFO("Not valid HWIdentifier for channel "<<ch);
               continue;
            }
            if( m_isSC && (! m_onlineHelper->is_slar(chanId)) ) {
               ATH_MSG_WARNING("Not a SC identifier, skipping ! ");
               continue;
            }
            try { const HWIdentifier chanIdd(chanId.get_identifier32().get_compact());chanIdd.show();}
            catch (...) {
               ATH_MSG_WARNING("Something wrong with this id, skipping ! ");
               continue;
            }
            const std::vector<HWIdentifier>& cLids=clCont->calibSlotLine(chanId); 
            msg()<<MSG::DEBUG <<" CL size: "<<cLids.size()<<": ";
            for(unsigned cl=0; cl<cLids.size(); ++cl) msg()<<MSG::DEBUG <<cLids[cl].get_identifier32().get_compact()<<" ";
            msg() << endmsg;
            for(unsigned cl=0; cl<cLids.size(); ++cl) {
               const HWIdentifier calibModuleID = m_onlineHelper->calib_module_Id(cLids[cl]);
               if (std::find(m_patchCBs.begin(),m_patchCBs.end(),calibModuleID.get_identifier32().get_compact()) != m_patchCBs.end()) { // we should patch this channel
                  missingCBs.push_back(std::make_pair(std::make_pair(febId,gain), ch));
                  break;
               }
            } // over CLs
         }// over channels
         retVal1=false;
      } 
        
   
    }//End loop over FEBs in subset
    ++subsetIndex;
  }//End loop over subsets in container
 
  ATH_MSG_INFO("missing.size(): "<<missing.size()<<"  missingCBs.size(): "<<missingCBs.size());
 
  if (missing.size()) 
    retVal=patchMissingFEBs(missing,cabling,bcCont);
 
  if (m_patchMissingFEBs && m_useCorrChannel) {
    const std::vector<unsigned> completedChans = m_nc_validation->completeCorrectionChannels();
    if (completedChans.size()>0) {
      msg() << MSG::INFO <<  "Artificially inserted correction subsets in COOL channels" ;
      for(size_t j=0;j<completedChans.size();++j) 
    msg() << MSG::INFO << " " << completedChans[j];
      msg() << MSG::INFO << endmsg;
    }
  }
  if (retVal) 
    ATH_MSG_INFO ( "All Cool channel completly filled (" << multiChanColl->size() << " subsets)"  ) ;
  else
    ATH_MSG_ERROR ( "Not all COOL channnels completely filled" ) ;
 
   if (missingCBs.size()) retVal1 = patchMissingCalibBoards(missingCBs,cabling,bcCont);
   if (retVal1)
      ATH_MSG_INFO ( "All missing CalibBoards completly filled "  ) ;
   else
      ATH_MSG_ERROR ( "Not all CalibBoards completely filled" ) ;
 
  ATH_MSG_INFO("checkCoolChannelCompleteness done....");
  return retVal && retVal1;
}
 
 
template<class CONDITIONSCONTAINER, class REFCONTAINER>
bool LArCalibValidationAlg<CONDITIONSCONTAINER, REFCONTAINER>::patchMissingFEBs(const FEBANDGAIN_t& febAndGain, const LArOnOffIdMapping *cabling, const LArBadChannelCont *bcCont) {
  unsigned nGood=0;
  FEBANDGAIN_t::const_iterator missingIt=febAndGain.begin();
  FEBANDGAIN_t::const_iterator missingIt_e=febAndGain.end();
  for (;missingIt!=missingIt_e;++missingIt) {
    const HWIdentifier febId=missingIt->first;
    const unsigned gain=missingIt->second;
    const int nChan=m_onlineHelper->channelInSlotMax(febId);
    
    //Insert at least one (dummy) value for the missing FEB so it showes up the feb-map. 
    //Creating corrections for inexisting channels causes problems.
    const HWIdentifier firstChannel=m_onlineHelper->channel_Id(febId,0);
    const typename CONDITIONSCONTAINER::LArCondObj dummy;
    m_nc_validation->setPdata(firstChannel,dummy,gain);
    
    //Loop over all channels of this FEB and insert corrections for it
    int nMissing=0;
    for (int ch=0;ch<nChan;ch++) {
      const HWIdentifier chid=m_onlineHelper->channel_Id(febId,ch);
      const LArCondObj obj = getRefObj(chid,gain);
      if (obj.isEmpty()) { //Can't get reference object
    if (cabling->isOnlineConnected(chid)) { //Don't care if not connected
      ATH_MSG_ERROR ( "Channel " << ch << " of missing " <<  channelDescription(febId,cabling, bcCont, gain,true) 
                          << " can't be found in reference container either." ) ;
      ++nMissing;
    }//end if isConnected
      }//end if isEmpty
      else {
    StatusCode sc=m_nc_validation->insertCorrection(chid,obj,gain,m_useCorrChannel);
    if (sc.isFailure()) {
      ++nMissing;
      ATH_MSG_ERROR ( "Failed to insert correction for channel " << ch << " of missing " <<  channelDescription(febId,cabling, bcCont, gain,true) ) ;
    }
    else {
      ATH_MSG_DEBUG ( "Copied channel " << ch << " of missing " <<  channelDescription(febId,cabling, bcCont,gain,true) 
                          << " from reference container" ) ;
    }
      ++nGood;
      }
    }//end loop over channels of feb
    if (nMissing==0)
      ATH_MSG_INFO ( "Sucessfully patched " << channelDescription(febId,cabling,bcCont,gain,true) << " using values from the reference container." ) ; 
    else 
      ATH_MSG_ERROR ( "Failed to patch all channels of FEB" << channelDescription(febId,cabling,bcCont,gain,true) ) ; 
      
  }//end loop over all pairs of missing febid and gain
 
  if (nGood>0) 
    return true;
  else
    return false; //Looks like this FEB isn't in the reference container either.
}
 
template<class CONDITIONSCONTAINER, class REFCONTAINER>
bool LArCalibValidationAlg<CONDITIONSCONTAINER, REFCONTAINER>::patchMissingCalibBoards(const CBANDCHANANDGAIN_t& CBAndGain, const LArOnOffIdMapping *cabling, const LArBadChannelCont *bcCont) {
  unsigned nGood=0;
  unsigned nMissing=0;
  CBANDCHANANDGAIN_t::const_iterator missingIt=CBAndGain.begin();
  CBANDCHANANDGAIN_t::const_iterator missingIt_e=CBAndGain.end();
  for (;missingIt!=missingIt_e;++missingIt) {
    const HWIdentifier febId=(missingIt->first).first;
    const unsigned gain=(missingIt->first).second;
    const int chan=missingIt->second;
    
    //Insert at least one (dummy) value for the missing channel so it showes up the feb-map. 
    //Creating corrections for inexisting channels causes problems.
    const HWIdentifier ourChannel=m_onlineHelper->channel_Id(febId,chan);
    const typename CONDITIONSCONTAINER::LArCondObj dummy;
    m_nc_validation->setPdata(ourChannel,dummy,gain);
    
    const LArCondObj obj = getRefObj(ourChannel,gain);
    if (obj.isEmpty()) { //Can't get reference object
    if (cabling->isOnlineConnected(ourChannel)) { //Don't care if not connected
      ATH_MSG_ERROR ( "Channel " << chan << " of FEB " <<  channelDescription(febId,cabling,bcCont,gain,true) 
                          << " can't be found in reference container either." ) ;
      ++nMissing;
    }//end if isConnected
    }//end if isEmpty
    else {
    StatusCode sc=m_nc_validation->insertCorrection(ourChannel,obj,gain,m_useCorrChannel);
    if (sc.isFailure()) {
      ++nMissing;
      ATH_MSG_ERROR ( "Failed to insert correction for channel " << chan << " of FEB " <<  channelDescription(febId,cabling,bcCont,gain,true) ) ;
    } else {
      ATH_MSG_DEBUG ( "Copied channel " << chan << " of FEB " <<  channelDescription(febId,cabling,bcCont,gain,true) 
                          << " from reference container" ) ;
        ++nGood;
    }
    }
 
  }//end loop over  febid and gain and channels
 
  if (nMissing==0)
      ATH_MSG_INFO ( "Sucessfully patched all " << nGood << " channels by using values from the reference container." ) ; 
  else 
      ATH_MSG_ERROR ( "Failed to patch all asked channels, only " << nGood << " channels patched") ; 
      
 
  return nGood>0; //Do we have good patched channels ?
}