PixelPortcardMap.cc

Go to the documentation of this file.

//
// This class provides the mapping between
// portcards and the modules controlled by
// the card
//
//
//
 
#include "CalibFormats/SiPixelObjects/interface/PixelPortcardMap.h"
#include "CalibFormats/SiPixelObjects/interface/PixelTimeFormatter.h"

#include <sstream>
#include <cassert>
#include <stdexcept>

using namespace pos;
using namespace std;

PixelPortcardMap::PixelPortcardMap(std::vector< std::vector < std::string> > &tableMat):PixelConfigBase(" "," "," "){

  std::string mthn = "[PixelPortcardMap::PixelPortcardMap()]\t\t\t    " ;
  std::vector< std::string > ins = tableMat[0];
  std::map<std::string , int > colM;
  std::vector<std::string > colNames;
/*
  EXTENSION_TABLE_NAME: PIXEL_PORTCARD_MAP (VIEW: CONF_KEY_PORTCARD_MAP_V)

  CONFIG_KEY                    NOT NULL VARCHAR2(80)
  KEY_TYPE                  NOT NULL VARCHAR2(80)
  KEY_ALIAS                 NOT NULL VARCHAR2(80)
  VERSION                        VARCHAR2(40)
  KIND_OF_COND                  NOT NULL VARCHAR2(40)
  PORT_CARD                 NOT NULL VARCHAR2(200)
  PANEL_NAME                    NOT NULL VARCHAR2(200)
  TBM_MODE                       VARCHAR2(200)
  AOH_CHAN                  NOT NULL NUMBER(38)
*/
  colNames.push_back("CONFIG_KEY"  );
  colNames.push_back("KEY_TYPE"    );
  colNames.push_back("KEY_ALIAS"   );
  colNames.push_back("VERSION"     );
  colNames.push_back("KIND_OF_COND");
  colNames.push_back("PORT_CARD"   );
  colNames.push_back("PANEL_NAME"  );
  colNames.push_back("TBM_MODE"    );
  colNames.push_back("AOH_CHAN"    );
/*
  colNames.push_back("CONFIG_KEY_ID" );
  colNames.push_back("CONFG_KEY"     );
  colNames.push_back("VERSION"       );
  colNames.push_back("KIND_OF_COND"  );
  colNames.push_back("SERIAL_NUMBER" );
  colNames.push_back("PORT_CARD"     );
  colNames.push_back("PANEL_NAME"    );
  colNames.push_back("TBM_MODE"      );
  colNames.push_back("AOH_CHAN"      );
 */ 
  for(unsigned int c = 0 ; c < ins.size() ; c++)
    {
      for(unsigned int n=0; n<colNames.size(); n++)
    {
      if(tableMat[0][c] == colNames[n])
        {
          colM[colNames[n]] = c;
          break;
        }
    }
    }//end for
  /*
  for(unsigned int n=0; n<colNames.size(); n++)
    {
      if(colM.find(colNames[n]) == colM.end())
    {
      std::cerr << __LINE__ << "]\t" << mthn 
                << "Couldn't find in the database the column with name " << colNames[n] << std::endl;
      assert(0);
    }
    }
  */
    
    
  std::string portcardname;
  std::string modulename;
  unsigned int aoh;
  std::string aohstring;
  std::string tbmChannel;
  
  for(unsigned int r = 1 ; r < tableMat.size() ; r++){    //Goes to every row of the Matrix
    
    portcardname = tableMat[r][colM["PORT_CARD"]];
    modulename   = tableMat[r][colM["PANEL_NAME"]];
    aohstring    = tableMat[r][colM["AOH_CHAN"]];
    tbmChannel   = tableMat[r][colM["TBM_MODE"]] ;
//     cout << "[PixelPortcardMap::PixelPortcardMap()]\t\t\t    "
//   << "Portcardname: " << portcardname
//   << "\tmodulename: "   << modulename
//   << "\taohstring: "    << aohstring
//   << "\ttbmChannel:"   << tbmChannel
//   << endl ;
    //aohname.erase(0,20);  // Is going to be change when Umesh put a AOH Channel column in the view.
    aoh = (((unsigned int)atoi(aohstring.c_str())));
    //std::cout<<aoh<<std::endl;
    PixelModuleName module(modulename);
    if (module.modulename()!=modulename)
      {
    std::cout << __LINE__ << "]\t" << mthn << "Modulename: " << modulename          << std::endl;
    std::cout << __LINE__ << "]\t" << mthn << "Parsed to : " << module.modulename() << std::endl;
    assert(0);
      }
    if(tbmChannel == "")
      {
    tbmChannel = "A";// assert(0); // add TBMChannel to the input, then remove assert
      }
    PixelChannel channel(module, tbmChannel);
    std::pair<std::string, int> portcardAndAOH(portcardname, aoh);
    map_[channel] = portcardAndAOH;
  }//end for r


}//end constructor
//*****************************************************************************

PixelPortcardMap::PixelPortcardMap(std::string filename):
  PixelConfigBase(" "," "," "){

  std::string mthn = "[PixelPortcardMap::PixelPortcardMap()]\t\t\t    " ;
  std::ifstream in(filename.c_str());

  if (!in.good()){
    std::cout << __LINE__ << "]\t" << mthn << "Could not open: " << filename <<std::endl;
    throw std::runtime_error("Failed to open file "+filename);
  }
  else {
    std::cout << __LINE__ << "]\t" << mthn << "Reading from: "   << filename <<std::endl;
  }
  
  std::string dummy;

  in >> dummy;
  in >> dummy;
  in >> dummy;
  in >> dummy;
  in >> dummy;

  do {
    
    std::string portcardname;
    std::string modulename;
    std::string TBMChannel = "A";
    std::string aoh_string;
    unsigned int aoh;

    in >> portcardname >> modulename >> aoh_string ;
    if (aoh_string == "A" || aoh_string == "B") // Optionally, the TBM channel may be specified after the module name.  Check for this.
      {
    TBMChannel = aoh_string;
    in >> aoh_string;
      }
    aoh = atoi(aoh_string.c_str());
    
    if (!in.eof() ){
      PixelModuleName module(modulename);
      if (module.modulename()!=modulename){
    std::cout << __LINE__ << "]\t" << mthn << "Modulename: " << modulename          << std::endl;
    std::cout << __LINE__ << "]\t" << mthn << "Parsed to : " << module.modulename() << std::endl;
    assert(0);
      }

      PixelChannel channel(module, TBMChannel);
      std::pair<std::string, int> portcardAndAOH(portcardname, aoh);
      map_[channel] = portcardAndAOH;
    }
        

  }while (!in.eof());
}

    
/*const std::map<PixelModuleName, int>& PixelPortcardMap::modules(std::string portcard) const{

  std::map<std::string,std::map<PixelModuleName, int> >::const_iterator theportcard=map_.find(portcard);

  if (theportcard==map_.end()) {
    std::cout << "Could not find portcard with name:"<<portcard<<std::endl;
  }

  return theportcard->second;

}*/

PixelPortcardMap::~PixelPortcardMap(){}


void PixelPortcardMap::writeASCII(std::string dir) const {

  
  std::string mthn = "[PixelPortcardMap::writeASCII()]\t\t\t\t    " ;
  if (dir!="") dir+="/";
  string filename=dir+"portcardmap.dat";
  
  ofstream out(filename.c_str());
  if(!out.good()){
    cout << __LINE__ << "]\t" << mthn << "Could not open file: " << filename << endl;
    assert(0);
  }

  out <<"# Portcard          Module                     AOH channel" <<endl;
  std::map< PixelChannel, std::pair<std::string, int> >::const_iterator i=map_.begin();
 for(;i!=map_.end();++i){
    out << i->second.first<<"   "
    << i->first.module()<<"       "
    << i->first.TBMChannel()<<"       "
    << i->second.second<<endl;
  }
  out.close();


}



const std::set< std::pair< std::string, int > > PixelPortcardMap::PortCardAndAOHs(const PixelModuleName& aModule) const
{
    std::set< std::pair< std::string, int > > returnThis;
    
    // Loop over the entire map, searching for elements matching PixelModuleName.  Add matching elements to returnThis.
    for( std::map< PixelChannel, std::pair<std::string, int> >::const_iterator map_itr = map_.begin(); map_itr != map_.end(); ++map_itr )
    {
        if ( map_itr->first.modulename() == aModule.modulename() )
        {
            returnThis.insert(map_itr->second);
        }
    }
    
    return returnThis;
}

// Added by Dario for Debbie (the PixelPortcardMap::portcards is way to slow for the interactive tool)
bool PixelPortcardMap::getName(std::string moduleName, std::string &portcardName)
{
    for( std::map< PixelChannel, std::pair<std::string, int> >::const_iterator map_itr = map_.begin(); map_itr != map_.end(); ++map_itr )
    {
        if ( map_itr->first.modulename() == moduleName )
        {
            portcardName = map_itr->second.first;
            return true ;
        }
    }
        return false ;
}

const std::set< std::string > PixelPortcardMap::portcards(const PixelModuleName& aModule) const
{
    std::set< std::string > returnThis;
    const std::set< std::pair< std::string, int > > portCardAndAOHs = PortCardAndAOHs(aModule);
    for ( std::set< std::pair< std::string, int > >::const_iterator portCardAndAOHs_itr = portCardAndAOHs.begin(); portCardAndAOHs_itr != portCardAndAOHs.end(); ++portCardAndAOHs_itr)
    {
        returnThis.insert( (*portCardAndAOHs_itr).first );
    }
    return returnThis;
}

const std::pair< std::string, int > PixelPortcardMap::PortCardAndAOH(const PixelModuleName& aModule, const PixelTBMChannel& TBMChannel) const
{
    return PortCardAndAOH(PixelChannel(aModule, TBMChannel));
}

const std::pair< std::string, int > PixelPortcardMap::PortCardAndAOH(const PixelModuleName& aModule, const std::string& TBMChannel) const
{
    return PortCardAndAOH(PixelChannel(aModule, TBMChannel));
}

const std::pair< std::string, int > PixelPortcardMap::PortCardAndAOH(const PixelChannel& aChannel) const
{
    std::map< PixelChannel, std::pair<std::string, int> >::const_iterator found = map_.find(aChannel);
    if ( found == map_.end() )
    {
        std::pair< std::string, int > returnThis("none", 0);
        return returnThis;
    }
    else
    {
        return found->second;
    }
}

std::set< PixelModuleName > PixelPortcardMap::modules(std::string portCardName) const
{
    std::set< PixelModuleName > returnThis;
    
    // Loop over the entire map, searching for elements matching portCardName.  Add matching elements to returnThis.
    for( std::map< PixelChannel, std::pair<std::string, int> >::const_iterator map_itr = map_.begin(); map_itr != map_.end(); ++map_itr )
    {
        if ( map_itr->second.first == portCardName )
        {
            returnThis.insert(map_itr->first.module());
        }
    }
    
    return returnThis;
}

std::set< std::string > PixelPortcardMap::portcards(const PixelDetectorConfig* detconfig)
{
    std::set< std::string > returnThis;

    if(detconfig != 0){
    
      //still done done in an awkward way, but this avoids an
          //double nested loop that we had in the first implementation
      const std::vector <PixelModuleName> moduleList=detconfig->getModuleList();
      std::set< std::string > moduleNames;
      for(std::vector <PixelModuleName>::const_iterator it=moduleList.begin(), it_end=moduleList.end(); it!=it_end; ++it){
        moduleNames.insert(it->modulename());
      }

      for( std::map< PixelChannel, std::pair<std::string, int> >::const_iterator map_itr = map_.begin(); map_itr != map_.end(); ++map_itr )
        {
          if ( moduleNames.find(map_itr->first.modulename()) != moduleNames.end() ){
          returnThis.insert(map_itr->second.first);
        }
        }
    
     
      
     
    }
    else{
    
      for( std::map< PixelChannel, std::pair<std::string, int> >::const_iterator map_itr = map_.begin(); map_itr != map_.end(); ++map_itr )
        {
          
          returnThis.insert(map_itr->second.first);
        }
      
    }
    
    return returnThis;
}
//=============================================================================================
void PixelPortcardMap::writeXMLHeader(pos::PixelConfigKey key, 
                                      int version, 
                                      std::string path, 
                                      std::ofstream *outstream,
                                      std::ofstream *out1stream,
                                      std::ofstream *out2stream) const
{
  std::string mthn = "[PixelPortcardMap::writeXMLHeader()]\t\t\t    " ;
  std::stringstream fullPath ;
  fullPath << path << "/Pixel_PortCardMap_" << PixelTimeFormatter::getmSecTime() << ".xml" ;
  std::cout << __LINE__ << "]\t" << mthn << "Writing to: " << fullPath.str() << std::endl ;
  
  outstream->open(fullPath.str().c_str()) ;
  
  *outstream << "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>"                    << std::endl ;
  *outstream << "<ROOT xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>"                       << std::endl ;
  *outstream << " <HEADER>"                                              << std::endl ;
  *outstream << "  <TYPE>"                                               << std::endl ;
  *outstream << "   <EXTENSION_TABLE_NAME>PIXEL_PORTCARD_MAP</EXTENSION_TABLE_NAME>"                         << std::endl ;
  *outstream << "   <NAME>Pixel Port Card Map</NAME>"                                        << std::endl ;
  *outstream << "  </TYPE>"                                              << std::endl ;
  *outstream << "  <RUN>"                                                << std::endl ;
  *outstream << "   <RUN_TYPE>Pixel Port Card Map</RUN_TYPE>"                                            << std::endl ;
  *outstream << "   <RUN_NUMBER>1</RUN_NUMBER>"                                          << std::endl ;
  *outstream << "   <RUN_BEGIN_TIMESTAMP>" << pos::PixelTimeFormatter::getTime() << "</RUN_BEGIN_TIMESTAMP>" << std::endl ;
  *outstream << "   <LOCATION>CERN P5</LOCATION>"                                                            << std::endl ; 
  *outstream << "  </RUN>"                                               << std::endl ;
  *outstream << " </HEADER>"                                                 << std::endl ;
  *outstream << ""                                               << std::endl ;
  *outstream << " <DATA_SET>"                                                << std::endl ;
  *outstream << "  <PART>"                                                                                   << std::endl ;
  *outstream << "   <NAME_LABEL>CMS-PIXEL-ROOT</NAME_LABEL>"                                                 << std::endl ;
  *outstream << "   <KIND_OF_PART>Detector ROOT</KIND_OF_PART>"                                              << std::endl ;
  *outstream << "  </PART>"                                                                                  << std::endl ;
  *outstream << "  <VERSION>"             << version      << "</VERSION>"                    << std::endl ;
  *outstream << "  <COMMENT_DESCRIPTION>" << getComment() << "</COMMENT_DESCRIPTION>"                << std::endl ;
  *outstream << "  <CREATED_BY_USER>"     << getAuthor()  << "</CREATED_BY_USER>"                << std::endl ;
}

//=============================================================================================
void PixelPortcardMap::writeXML(std::ofstream *outstream,
                                std::ofstream *out1stream,
                                std::ofstream *out2stream) const 
{
  std::string mthn = "[PixelPortcardMap::writeXML()]\t\t\t    " ;


  std::map< PixelChannel, std::pair<std::string, int> >::const_iterator i=map_.begin();
  for(;i!=map_.end();++i){
     *outstream << "  <DATA>"                                                                    << std::endl ;
     *outstream << "   <PORT_CARD>"  << i->second.first       << "</PORT_CARD>"                  << std::endl ;
     *outstream << "   <PANEL_NAME>" << i->first.module()     << "</PANEL_NAME>"                 << std::endl ;
     *outstream << "   <TBM_MODE>"   << i->first.TBMChannel() << "</TBM_MODE>"                   << std::endl ;
     *outstream << "   <AOH_CHAN>"   << i->second.second      << "</AOH_CHAN>"                   << std::endl ;
     *outstream << "  </DATA>"                                                                   << std::endl ;
   }  
}

//=============================================================================================
void PixelPortcardMap::writeXMLTrailer(std::ofstream *outstream,
                                       std::ofstream *out1stream,
                                       std::ofstream *out2stream) const
{
  std::string mthn = "[PixelPortcardMap::writeXMLTrailer()]\t\t\t    " ;
  
  *outstream << " </DATA_SET>"                                                       << std::endl ;
  *outstream << "</ROOT> "                                                   << std::endl ;

  outstream->close() ;
}