pit_configuration.cpp

Go to the documentation of this file.

#include <iostream>
#include <fstream>
#include<sstream>
#include <exception>

#include "pit_configuration.h"

using namespace std;

pit_configuration::pit_configuration() {


  
  logPitConfiguration = &(log4cpp::Category::getInstance("pitLog.configuration"));
  logPitConfiguration->info("Constructor of pit_configuration");

  // sets the default configuration
  this->setDefaultCoordinates();
  this->setDefaultRequiredChannels();
  
}

/*******************************************************************
 * getInstance methods allow instantiation of a single instance of this class (singleton)
*******************************************************************/
pit_configuration& pit_configuration::getInstance() {
  static  pit_configuration singleton;
  return (singleton);
}

/******************************************************************* 
 * sets all required channels to the default values (for the moment all to true)
 * ****************************************************************/
void pit_configuration::setDefaultRequiredChannels(void){
        for (int board = 0 ; board < NUMBER_OPTIN; board ++){
                for (int link = 0 ; link < NUMBER_OPTICAL_LINKS ; link ++){
                        for(int foChannel=0; foChannel< NUMBER_FO_CHANNELS; foChannel++)
                        requiredChannels[board][link][foChannel]=true;
                }
        }
        
}
/*********************************************************************************
 * function to print the internal table of optical link assignments pit_coordinate
 * ordered by "sector", "side", "half stave" 
**********************************************************************************/
void pit_configuration::printPitCoordinateTable() const{

    t_sideCoord side = A;

    for (unsigned int sector=0; sector < NUMBER_SECTORS; sector ++) {
      for (unsigned int half_stave=0; half_stave < NUMBER_HALF_STAVES_SECTOR; half_stave++) {
        cout << "Side A sector " << sector << " half stave " << half_stave;
                cout << " => OPTIN board  " <<  pit_coordinate[side][sector][half_stave].optinNumber;
                cout << " link number  " <<  pit_coordinate[side][sector][half_stave].linkNumber;
                cout << endl;
      }
    }
    
    side = C;
    for (unsigned int sector=0; sector < NUMBER_SECTORS; sector ++) {
      for (unsigned int half_stave=0; half_stave < NUMBER_HALF_STAVES_SECTOR; half_stave++) {
                cout << "Side C sector " << sector << " half stave " << half_stave;
                cout << " => OPTIN board  " <<  pit_coordinate[side][sector][half_stave].optinNumber;
                cout << " link number  " <<  pit_coordinate[side][sector][half_stave].linkNumber;
                cout << endl;
      }
    }


}

/*******************************************************************************************************
 * function to print the internal table of optical link assignments spd_coordinate
 * ordered by "optin board", "optical link" 
********************************************************************************************************/
void pit_configuration::printSpdCoordinateTable() const{
  for(int optinBoard = 0  ; optinBoard <NUMBER_OPTIN ; optinBoard++  ) {
    for (int opticalLink = 0; opticalLink<NUMBER_OPTICAL_LINKS; opticalLink++ ) {
      cout << "Board " << optinBoard << " link " << opticalLink;
      if ( spd_coordinate[optinBoard][opticalLink].side==A) cout << " => side A "; 
      if ( spd_coordinate[optinBoard][opticalLink].side==C) cout << " => side C "; 
      cout << " sector " << spd_coordinate[optinBoard][opticalLink].sector;
      cout << " half_stave " << spd_coordinate[optinBoard][opticalLink].half_stave;
      cout << endl;
    }
  }

}

/*************************************************************************************************
 *  parses one line of the required configuration list
 * white space separed arguments ex:
 *      1       A       0       1111100000
 * sector=1 side=A halfstave=0 first five foChannels not required last five required
 ************************************************************************************************/
bool pit_configuration::parseRequiredChannelLine(const string &line){
        // all the variables are initilalized with 0xffffffff 
        // to force the update in the function (if not there will be an error)
        unsigned int sector, halfstave;
        char side ;
        unsigned board, link;
        string requiredFos;
        
                        // if it is a comment does nothing
        if (line[0]==COMMENT_CHAR)return false;
        
        // initializes one istream object to do the formmating 
        stringstream stream(line);
        
        // reads the variables
        stream >> sector >> side >> halfstave >> requiredFos;
        
        link = getLinkNumber(side, sector, halfstave);
        board = getBoardNumber(side,sector,halfstave);
        this->setRequired( board, link , requiredFos);
        
        return true;

}

/**************************************************************************************
 *  function to set a required link required fastors with a binary string ex: 1110000011 
 ***************************************************************************************/
void pit_configuration::setRequired(unsigned int board,unsigned int link, const string &foChannelsValues ){
        unsigned int foChannel;
        
        for (foChannel = 0 ; (foChannel < NUMBER_FO_CHANNELS) || (foChannel < foChannelsValues.size()) ; foChannel ++){
                bool value;
                if (foChannelsValues[foChannel]=='1')value = true;
                else if (foChannelsValues[foChannel]=='0')value = false;
                else throw (out_of_range("(setRequired) if setting required fastor channels with a binary string use only '0' and '1's"));      
                
                this->setRequired(board, link , foChannel, value);
        }
                // if the string as less than 10 characters assumes that all the others are not required
        for (int index = foChannel; index < NUMBER_FO_CHANNELS; index++){
                this->setRequired(board, link,index,false);
        }
}

/*******************************************************************************
 *  sets the required channels: throws out_of_range if you get out of the  boundaries
 *******************************************************************************/
void pit_configuration::setRequired(unsigned int board,unsigned int link,unsigned int foChannel, bool value){
        if (board >= NUMBER_OPTIN || link >= NUMBER_OPTICAL_LINKS || foChannel >= NUMBER_FO_CHANNELS  ){
                throw (out_of_range("(setRequired) board number, link or fastor channel out of range"));
        }
        
        this->requiredChannels[board][link][foChannel]= value;
}
/*****************************************************************************
 * reads the required channels from a file
 * expects a white space separeted arguments with the follwing order
 *  sector     side    halfstave    requiredfastor(binary number) 
 * ex:  1       A       0       1111100000
*****************************************************************************/
void pit_configuration::openRequiredChannelsFile(const char * filename){
        fstream tableFile;
                
        logPitConfiguration->info("Opening required channels list file %s", filename);
        
        try {
                int nLines=0;   
                tableFile.open(filename, fstream::in);
                
                // if it cannot open the file throws the exception
                if (!tableFile.is_open()){
                        string errorString("(openRequiredChannelsFile) could not open file ");
                        errorString += filename;
                        throw (errorString);
                }
                
                string line;
                                
                // parses each line of the file
                while (getline(tableFile, line)){
                        if (parseRequiredChannelLine(line))     nLines++;
                }

                        // checks if we parsed the right number of lines
                if (nLines != NUMBER_HALF_STAVES){
                        stringstream errorMsg;
                        errorMsg << "(openRequiredChannelsFile) only "<< nLines << "found in required channels configuration file"; 
                        throw( errorMsg.str());
                }
                tableFile.close();
                return;
        }
        catch(out_of_range error){
                logPitConfiguration->error(error.what());       
        }
        catch(string error){
                logPitConfiguration->error(error);      
        }
        catch(...){
                
        }
                // this code will run if there was any exception
        logPitConfiguration->warn("(openRequiredChannelsFile) exception raised, falling back to default values");
        this->setDefaultRequiredChannels();
        if ( tableFile.is_open() )tableFile.close();
}

//*******************************************************************************************************

//********************************************************************************************************
bool pit_configuration::parseCoordinateLine(const string &line){
        
        // all the variables are initilalized with 0xffffffff 
        // to force the update in the function (if not there will be an error)
        unsigned int optinBoard, optinChannel;
        unsigned int sector,  halfStave;
        char charSide;
        t_sideCoord side;
        
                        // if it is a comment does nothing
        if (line[0]==COMMENT_CHAR) return false;
        
        // initializes one istream object to do the formmating 
        stringstream stream(line);
        
        // reads the variables
        stream >> optinBoard>>optinChannel>>sector>>charSide>>halfStave;
        
        if (charSide=='A')side =A;
        else side =C;
        
        // sets a value in the table
    this->setCoordinate( optinBoard, optinChannel, sector,(t_sideCoord) side, halfStave);
    return true;
}
/*******************************************************************
 * function to open a table from a file and load 
 * it will open a white space separated table with the following struture
 * <opin board number> <link number> <sector> <side> <half stave>   
*******************************************************************/
void pit_configuration::openCoordinateTableFile(const char *filename){
        fstream tableFile;
        logPitConfiguration->info("Opening coordinate table file %s", filename);
        
        try {
                int nLines=0;   
                tableFile.open(filename, fstream::in);
                
                // if it cannot open the file throws the exception
                if (!tableFile.is_open()){
                        string errorString("(openCoordinateTableFile) could not open file ");
                        errorString += filename;
                        logPitConfiguration->error(errorString);
                        throw (errorString);
                }
                
                
                string line;
                
                // parses each line of the file
                while (getline(tableFile, line)){
                        if (parseCoordinateLine(line))nLines++;
                }
                        
        // checks if we parsed the right number of lines
                if (nLines != NUMBER_OPTICAL_LINKS){
                        stringstream errorMsg;
                        errorMsg << "(openCoordinateTableFile) only "<< nLines << "found in required channels configuration file"; 
                        throw( errorMsg.str());
                }
                
                return;
        }
        catch(out_of_range error){
                logPitConfiguration->error(error.what());       
        }
        catch(string error){
                logPitConfiguration->error(error);      
        }
        catch(...){
                
        }
                // this code will run if there was any exception
        logPitConfiguration->warn("(openCoordinateTableFile) exception raised, falling back to default values");
        this->setDefaultCoordinates();

        if ( tableFile.is_open() )tableFile.close();
}


void pit_configuration::setDefaultCoordinates(void){

  t_sideCoord side;
  unsigned int sector;
  unsigned int half_stave;
  
  // first set of 5 optin boards
  for(int optinBoard = 0 ; optinBoard <NUMBER_OPTIN/2 ; optinBoard++  ) {

    for (int opticalLink = 0; opticalLink<NUMBER_OPTICAL_LINKS/2; opticalLink++ ){
      side = A;
      sector = 2*optinBoard;
      half_stave = opticalLink;
     
      this->setCoordinate(optinBoard, opticalLink, sector, side, half_stave );
   
    }
    for (int opticalLink = NUMBER_OPTICAL_LINKS/2 ; opticalLink<NUMBER_OPTICAL_LINKS; opticalLink++) {
      side = A;
      sector = 2*optinBoard + 1;
      half_stave = opticalLink  - NUMBER_OPTICAL_LINKS/2;
      
      this->setCoordinate(optinBoard, opticalLink, sector, side, half_stave);
        
    }
  }

  // second set of optin boards from 5 to 9
  for(int optinBoard = NUMBER_OPTIN/2  ; optinBoard <NUMBER_OPTIN ; optinBoard++  ) {


    for (int opticalLink = 0; opticalLink<NUMBER_OPTICAL_LINKS/2; opticalLink++ ){
      side = C;
      sector = 2*(optinBoard-NUMBER_OPTIN/2);
      half_stave = opticalLink;
      
      this->setCoordinate(optinBoard, opticalLink, sector, side, half_stave);
    
    }
    for (int opticalLink = NUMBER_OPTICAL_LINKS/2 ; opticalLink<NUMBER_OPTICAL_LINKS; opticalLink++) {
      side = C;
      sector = 2*(optinBoard-NUMBER_OPTIN/2) + 1;
      half_stave = opticalLink - NUMBER_OPTICAL_LINKS/2 ;
    
      this->setCoordinate(optinBoard, opticalLink, sector, side, half_stave);
    }
  }

}

void pit_configuration::setCoordinate(unsigned int optinBoard, unsigned int optinChannel,
                                                                                unsigned int sector, t_sideCoord side, unsigned int halfStave){
        
                // does the booundary checking here
        if ( (optinBoard >= NUMBER_OPTIN) || (optinChannel >= NUMBER_OPTICAL_LINKS) || 
                (sector >= NUMBER_SECTORS) || (side >= NUMBER_SIDES) || (halfStave >= NUMBER_HALF_STAVES_SECTOR)){
                
                
                logPitConfiguration->crit("(setCoordinate) out of range %d,%d,%d,%d,%d",
                                                                                        optinBoard, optinChannel, side, sector, halfStave);
                
                throw out_of_range("(setCoordinate)optin board or optin channel  out of range");

        }
        
        
        // sets a value in the table
    spd_coordinate[optinBoard][optinChannel].side = side;
    spd_coordinate[optinBoard][optinChannel].sector= sector;
    spd_coordinate[optinBoard][optinChannel].half_stave= halfStave;

    pit_coordinate[side][sector][halfStave].optinNumber = optinBoard;
    pit_coordinate[side][sector][halfStave].linkNumber = optinChannel;
        
}

unsigned int pit_configuration::getBoardNumber(char side , unsigned int  sector , unsigned int halfstave)const {
        t_sideCoord coordSide;
        
        if (side =='A'|| side =='a'){
                coordSide=A;
        }
        else if (side =='C'|| side =='c'){
                coordSide=C;
        }
        else {
                logPitConfiguration->error("(pit_configuration::getBoardNumber) side has to be 'A' or 'C' ");
                throw out_of_range("(pit_configuration::getBoardNumber): side has to be 'A' or 'C' ");
        }
        
        return getBoardNumber(coordSide, sector, halfstave);
}

unsigned int pit_configuration::getLinkNumber(char side , unsigned int sector, unsigned int halfstave)const {
        t_sideCoord coordSide;
        
        if (side =='A'|| side =='a'){
                coordSide=A;
        }
        else if (side =='C'|| side =='c'){
                coordSide=C;
        }
        else {
                logPitConfiguration->error("(pit_configuration::getLinkNumber): side has to be 'A' or 'C' ");
                throw out_of_range ("(pit_configuration::getLinkNumber): side has to be 'A' or 'C' ");
        }
        
        return getLinkNumber(coordSide, sector, halfstave);
}

unsigned int pit_configuration::getBoardNumber(t_sideCoord side,unsigned int sector,unsigned int halfstave)const{
        
        if ((sector >= NUMBER_SECTORS) || (halfstave >= NUMBER_HALF_STAVES_SECTOR)){
                logPitConfiguration->error("(pit_configuration::getBoardNumber): out of range %d,%d",sector,halfstave);
                throw out_of_range ("(pit_configuration::getBoardNumber): sector or halfstave out of range");
        }
        return pit_coordinate[side][sector][halfstave].optinNumber;
}

unsigned int pit_configuration::getLinkNumber(t_sideCoord side,unsigned int sector,unsigned int halfstave)const{
        if ((sector >= NUMBER_SECTORS) || (halfstave >= NUMBER_HALF_STAVES_SECTOR)){
                logPitConfiguration->error("(pit_configuration::getLinkNumber) out of range %d,%d",sector,halfstave);
                throw out_of_range ("(pit_configuration::getLinkNumber): sector or halfstave out of range");
        }
        return pit_coordinate[side][sector][halfstave].linkNumber;
}

bool pit_configuration::getFastorRequired(unsigned int board, unsigned int link, unsigned int foChannel )const{
        if ( (board >= NUMBER_OPTIN) || (link >= NUMBER_OPTICAL_LINKS) || foChannel >= (NUMBER_FO_CHANNELS)){
                logPitConfiguration->error("(pit_configuration::getFastorRequired): out of range %d,%d,%d", board,link,foChannel);
                throw out_of_range("(pit_configuration::getFastorRequired): board, link or fastor channel out of range");
        }
        
        return requiredChannels[board][link][foChannel];
}

string pit_configuration::getFastorRequired(unsigned int board, unsigned int link)const{
        string out("");
        
        for (int foChannel = 0 ; foChannel < NUMBER_FO_CHANNELS; foChannel ++){
                
                if (requiredChannels[board][link][foChannel] ) out.push_back('1');
                else out.push_back('0');
        }
        
        return out;
}
void pit_configuration::printRequiredChannelList()const{
        for(int board = 0; board < NUMBER_OPTIN ; board ++){
                for (int link = 0 ; link < NUMBER_OPTICAL_LINKS ; link ++){
                        cout << "optin board "<< board << ", optical Link " << link<<" = " << getFastorRequired(board, link).c_str() << endl;  
                }
        }
        
}

bool pit_configuration::getLinkRequired(unsigned int board,unsigned int link)const{
        
        string foRequired =this->getFastorRequired(board, link);
        
        if (foRequired=="0000000000") return true;
        else return false;
}
void pit_configuration::dumpCoordinateTableToFile(const char *filename)const{
        fstream coordinateListFile;
        logPitConfiguration->info("dumping coordinate list to %s",filename);
        coordinateListFile.open(filename, fstream::out);
        
        if (!coordinateListFile.is_open()){
                logPitConfiguration->error("(dumpCoordinateTableToFile)could not open %s",filename);
                return;
        }
        
        coordinateListFile<<"#coordinate file table\n";
        coordinateListFile<<"# board\tlink\tsector\tside\thalfstave\n";
        
        char charSide;

        for (int board = 0 ; board < NUMBER_OPTIN ; board ++){
                for (int link = 0 ; link < NUMBER_OPTICAL_LINKS; link ++){
                        
                        if (getSide(board, link)==A)charSide='A';
                        else charSide='C';
                        
                        coordinateListFile<<"\t"<< board<< '\t'<< link;
                        coordinateListFile<<"\t"<<getSector(board, link);
                        coordinateListFile<<"\t\t"<<charSide;
                        coordinateListFile<<"\t"<<getHalfStave(board,link)<<endl;
                }
        }
}

void pit_configuration::dumpRequiredLinksToFile(const char * filename)const{
        fstream requiredListFile;
        
        logPitConfiguration->info("dumping required link list to %s",filename);
        requiredListFile.open(filename, fstream::out);
        if (!requiredListFile.is_open()){
                logPitConfiguration->error("(dumpRequiredLinksToFile)could not open file  %s",filename);

                return;
        }
        
        requiredListFile<<"#required fastors file table\n";
        requiredListFile<<"# sector\tside\thalfstave\tfastorlist\n";

        char charSide;
        unsigned int link, board;
        
        for (int sector = 0 ; sector < NUMBER_SECTORS ; sector ++){
                for (int side = 0 ; side < NUMBER_SIDES; side ++){
                        for (int halfstave = 0 ; halfstave < NUMBER_HALF_STAVES_SECTOR; halfstave ++){
                                if (side == 0) charSide='A';
                                else charSide='C';
                                link=getLinkNumber(charSide, sector, halfstave);
                                board= getBoardNumber(charSide, sector, halfstave);
                                requiredListFile << '\t'<<sector<<'\t'<<charSide<<'\t'<<halfstave;
                                requiredListFile << "\t\t"<< getFastorRequired(board, link).c_str()<< endl;
                        }
                }
        }
}

---