GenABIO.cc

Go to the documentation of this file.

// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: t; tab-width: 8; -*-

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <cassert>
#include <cstdlib>
#include <cstring>

#include "ecalDccMap.h"

#if !defined(__linux__) && !(defined(__APPLE__) && __DARWIN_C_LEVEL >= 200809L)
#include <errno.h>
/* getline implementation is copied from glibc. */

#ifndef SIZE_MAX
# define SIZE_MAX ((size_t) -1)
#endif
#ifndef SSIZE_MAX
# define SSIZE_MAX ((ssize_t) (SIZE_MAX / 2))
#endif
namespace {
ssize_t getline (char **lineptr, size_t *n, FILE *fp)
{
    ssize_t result;
    size_t cur_len = 0;

    if (lineptr == NULL || n == NULL || fp == NULL)
    {
        errno = EINVAL;
        return -1;
   }

    if (*lineptr == NULL || *n == 0)
    {
        *n = 120;
        *lineptr = (char *) malloc (*n);
        if (*lineptr == NULL)
        {
            result = -1;
            goto end;
        }
    }

    for (;;)
    {
        int i;

        i = getc (fp);
        if (i == EOF)
        {
            result = -1;
            break;
        }

        /* Make enough space for len+1 (for final NUL) bytes.  */
        if (cur_len + 1 >= *n)
        {
            size_t needed_max =
                SSIZE_MAX < SIZE_MAX ? (size_t) SSIZE_MAX + 1 : SIZE_MAX;
            size_t needed = 2 * *n + 1;   /* Be generous. */
            char *new_lineptr;

            if (needed_max < needed)
                needed = needed_max;
            if (cur_len + 1 >= needed)
            {
                result = -1;
                goto end;
            }

            new_lineptr = (char *) realloc (*lineptr, needed);
            if (new_lineptr == NULL)
            {
                result = -1;
                goto end;
            }

            *lineptr = new_lineptr;
            *n = needed;
        }

        (*lineptr)[cur_len] = i;
        cur_len++;

        if (i == '\n')
            break;
    }
    (*lineptr)[cur_len] = '\0';
    result = cur_len ? (ssize_t) cur_len : result;

end:
    return result;
}
}
#endif


using namespace std;

const static int nEndcapXBins = 100;
const static int nEndcapYBins = 100;
const static int supercrystalEdge = 5;
const static int nSupercrystalXBins = nEndcapXBins/supercrystalEdge;
const static int nSupercrystalYBins = nEndcapYBins/supercrystalEdge;
const static int nEndcaps = 2;
const static int nEndcapTTInEta = 11;
const static int nBarrelTTInEta = 34;
const static int nTTInEta =
2*nEndcapTTInEta+nBarrelTTInEta;
const static int nTTInPhi = 72;
const int nABInEta=4;
const int nABInPhi=3;
const int nDCCEE = 9;
const int nABABCh = 8;//nbr of AB input/output ch. on an AB
const int nABTCCCh = 12;//nbr of TCC inputs on an AB
const int nDCCCh = 12;//nbr of DCC outputs on an AB
const int nTCCInEta = 6; //nbr of TCC bins along eta
const int nAB = nABInPhi*nABInEta;
const int nTTInABAlongPhi=nTTInPhi/nABInPhi;
const int iTTEtaMin[nABInEta] = {0,11,28,45};
const int iTTEtaMax[nABInEta] = {10,27,44,55};
const int iTTEtaSign[nABInEta] = {-1,-1,1,1};

//Eta bounds for TCC partionning
//a TCC covers from iTCCEtaBounds[iTCCEta] included to
//iTCCEtaBounds[iTCCEta+1] excluded.
const int iTCCEtaBounds[nTCCInEta+1] = {0,7,11,28,45,49,56};

const char* abTTFFilePrefix = "TTF_AB";
const char* abTTFFilePostfix = ".txt";
const char* abSRFFilePrefix = "AF_AB";
const char* abSRFFilePostfix = ".txt";
const char* abIOFilePrefix = "IO_AB";
const char* abIOFilePostfix = ".txt";

const char* srfFilename = "SRF.txt";
const char* ttfFilename = "TTF.txt";
const char* xconnectFilename = "xconnect_universal.txt";

const char srpFlagMarker[] = {'.', 'S', 'N', 'C', '4','5','6','7'};
const char tccFlagMarker[] = {'.', 'S', '?', 'C', '4', '5', '6', '7'};

char srp2roFlags[128];

typedef enum {suppress=0, sr2, sr1, full, fsuppress, fsr2, fsr1, ffull} roAction_t;
char roFlagMarker[] = {/*suppress*/'.', /*sr1*/'z', /*sr1*/'Z', /*full*/'F',
               /*fsuppress*/'4', /*fsr2*/'5', /*fsr1*/'6', /*ffull*/'7'
};

const int nactions = 8;
//can be overwritten according by cmd line arguments
roAction_t actions[nactions] = {/*LI->*/sr2,/*S->*/full,/*N->*/ full,/*C->*/full,
                /*fLI->*/sr2,/*fS->*/sr2,/*fN->*/sr2,/*fC->*/sr2}; 

//list of SC deserves by an endcap DCC [0(EE-)|1(EE+)][iDCCPhi]
vector<pair<int, int> > ecalDccSC[nEndcaps][nDCCEE];

void fillABTTFFiles(const char ttFlags[nTTInEta][nTTInPhi],
                    ofstream files[]);
void fillABSRPFiles(const char barrelSrFlags[nBarrelTTInEta][nTTInPhi],
                    const char endcapSrFlags[nEndcaps][nSupercrystalXBins]
                    [nSupercrystalYBins],
                    ofstream files[]);
void fillABIOFiles(const char ttFlags[nTTInEta][nTTInPhi],
                   const char barrelSrFlags[nBarrelTTInEta][nTTInPhi],
                   const char endcapSrFlags[nEndcaps][nSupercrystalXBins]
                   [nSupercrystalYBins],
                   ofstream files[]);
inline int abNum(int iABEta, int iABPhi){return 3*iABEta+iABPhi;}

bool readTTF(FILE* file, char ttFlags[nTTInEta][nTTInPhi]);
bool readSRF(FILE* file,
         char barrelSrFlags[nBarrelTTInEta][nTTInPhi],
         char endcapSrFlags[nEndcaps][nSupercrystalXBins]
         [nSupercrystalYBins]);

void writeABTTFFileHeader(ofstream& f, int abNum);
void writeABSRFFileHeader(ofstream& f, int abNum);
void writeABIOFileHeader(ofstream& f, int abNum);
string getFlagStream(char flags[nTTInEta][nTTInPhi], int iEtaMin, int iEtaMax,
                     int iPhiMin, int iPhiMax);
string getABTCCInputStream(const char tccFlags[nTTInEta][nTTInPhi],
                           int iABEta, int iABPhi, int iTCCCh);
void getABTTPhiBounds(int iABPhi, int& iTTPhiMin, int& iTTPhiMax);
string getABABOutputStream(const char tccFlags[nTTInEta][nTTInPhi],
                           int iABEta, int iABPhi, int iABCh);
string getABABInputStream(const char tccFlags[nTTInEta][nTTInPhi], int iABEta, 
              int iABPhi, int iABCh);
string getABDCCOutputStream(const char barrelSrFlags[nBarrelTTInEta][nTTInPhi],
                            const char endcapSrFlags[nEndcaps][nSupercrystalXBins]
                            [nSupercrystalYBins],
                            int iABEta, int iABPhi, int DCCCh);
void abConnect(int iAB,int iABCh,int& iOtherAB,int& iOtherABCh);

int iEvent = 0;

int theAB = -1;

int main(int argc, char* argv[]){
  char barrelSrFlags[nBarrelTTInEta][nTTInPhi];
  char endcapSrFlags[nEndcaps][nEndcapXBins/5][nEndcapYBins/5];
  char ttFlags[nTTInEta][nTTInPhi];
  ofstream abTTFFiles[nAB];
  ofstream abSRFFiles[nAB];
  ofstream abIOFiles[nAB];

  int iarg = 0;
  while(++iarg<argc){
    if(strcmp(argv[iarg],"-h")==0||strcmp(argv[iarg],"--help")==0){
      cout << "Usage: GenABIO [OPTIONS]\n\n"
    "Produces TT and SR flag files for each SRP board from TTF.txt and "
    "SRF.txt global flag files. Requires the SRP cross-connect description"
    " description file (xconnect_universal.txt). TTF.txt, SRF.txt and "
    "xconnect_universal.txt must be in the directory the command is "
    "launched.\n\n"
    "OPTIONS:\n"
        "  -A, --actions IJKLMNOP. IJKLMNOP I..P integers from 0 to 7.\n"
    "                I: action flag for low interest RUs\n"
    "                J: action flag for single RUs\n"
    "                K: action flag for neighbour RUs\n"
    "                L: action flag for centers RUs\n"
    "                M: action flag for forced low interest RUs\n"
    "                N: action flag for forced single RUs\n"
    "                O: action flag for forced neighbour RUs\n"
    "                P: action flag for forced centers RUs\n\n"
    " -h, --help display this help\n"
    " -a n, --ab n specifies indices of the AB whose file must be "
    "produced. The ab number runs from 1 to 12. Use -1 to produce files "
    "for every AB\n\n"
    ;
      
      return 0;
    }
    
    if(!strcmp(argv[iarg],"-A") || !strcmp(argv[iarg],"-A")){//actions
      if(++iarg>=argc){ cout << "Option error. Try -h\n"; return 1; }
      for(int i=0; i<8; ++i){
    int act = argv[iarg][i]-'0';
    if(act<0 || act>=nactions){
      cout << "Error. Action argument is invalid.\n";
      return 1;
    } else{
      actions[i] = (roAction_t)act;
    }
      }
      continue;
    }
    if(!strcmp(argv[iarg],"-a")||!strcmp(argv[iarg],"--ab")){
      if(++iarg>=argc){ cout << "Option error. Try -h\n"; return 1; }
      theAB = strtoul(argv[iarg], 0, 0);
      if(theAB>=0) --theAB;
      if(theAB<-1 || theAB>11){
    cout << "AB number is incorrect. Try -h option to get help.\n";
      }
      continue;
    }
  }

  for(size_t i=0; i<sizeof(srp2roFlags)/sizeof(srp2roFlags[0]); srp2roFlags[i++]='?');
  for(size_t i=0; i<sizeof(actions)/sizeof(actions[0]); ++i){
    srp2roFlags[(int)srpFlagMarker[i]] = roFlagMarker[actions[i]];
  }

  for(int iEE=0; iEE < nEndcaps; ++iEE){
    for(int iY = 0; iY < nSupercrystalXBins; ++iY){
      for(int iX = 0; iX < nSupercrystalYBins; ++iX){
    int iDCCPhi = dccPhiIndexOfRU(iEE==0?0:2,iX,iY);
    if(iDCCPhi>=0){//SC exists
      ecalDccSC[iEE][iDCCPhi].push_back(pair<int,int>(iX,iY));
    }
      }
    }
  }
  
  stringstream s;
  for(int iAB=0; iAB< nAB; ++iAB){
    if(theAB!=-1 && theAB!=iAB) continue;
    s.str("");
    s << abTTFFilePrefix << (iAB<9?"0":"") << iAB+1 << abTTFFilePostfix;
    abTTFFiles[iAB].open(s.str().c_str(), ios::out);
    writeABTTFFileHeader(abTTFFiles[iAB], iAB);
    s.str("");
    s << abSRFFilePrefix << (iAB<9?"0":"") << iAB+1 << abSRFFilePostfix;
    abSRFFiles[iAB].open(s.str().c_str(), ios::out);
    writeABSRFFileHeader(abSRFFiles[iAB], iAB);
    s.str("");
    s << abIOFilePrefix << (iAB<9?"0":"") << iAB+1 << abIOFilePostfix;
    abIOFiles[iAB].open(s.str().c_str(), ios::out);
    writeABIOFileHeader(abIOFiles[iAB], iAB);
  }

  FILE* srfFile = fopen(srfFilename, "r");
  if(srfFile==NULL){
    cerr << "Failed to open SRF file, " << srfFilename << endl;
    exit(EXIT_FAILURE);
  }

  FILE* ttfFile = fopen(ttfFilename, "r");
  if(ttfFile==NULL){
    cerr << "Failed to open TTF file, " << ttfFilename << endl;
    exit(EXIT_FAILURE);
  }
  
  iEvent = 0;
  while(readSRF(srfFile,barrelSrFlags,endcapSrFlags)
    && readTTF(ttfFile,ttFlags)){
    if(iEvent%100==0){
      cout << "Event " << iEvent << endl;
    }
    fillABTTFFiles(ttFlags,abTTFFiles);
    fillABSRPFiles(barrelSrFlags, endcapSrFlags, abSRFFiles);
    fillABIOFiles(ttFlags,barrelSrFlags,endcapSrFlags,abIOFiles);
    ++iEvent;
  }
  
  return 0;
}

void  fillABTTFFiles(const char ttFlags[nTTInEta][nTTInPhi],
             ofstream files[]){
  for(int iABEta=0; iABEta<nABInEta; ++iABEta){
    for(int iABPhi=0; iABPhi<nABInPhi; ++iABPhi){
      int iAB = abNum(iABEta,iABPhi);
      int iTTPhiMin;
      int iTTPhiMax;
      getABTTPhiBounds(iABPhi, iTTPhiMin, iTTPhiMax);
      //      writeEventHeader(files[iAB], iEvent, nTTInABAlongPhi);
      files[iAB] << "# Event " << iEvent << "\n";
      
      for(int i = 0 ; i <= iTTEtaMax[iABEta]-iTTEtaMin[iABEta];
      ++i){
    int iTTEta;
    if(iTTEtaSign[iABEta]>0){
      iTTEta = iTTEtaMin[iABEta] + i;
    } else{
      iTTEta = iTTEtaMax[iABEta] - i;
    }
    for(int iTTPhi = iTTPhiMin;
        mod(iTTPhiMax-iTTPhi,nTTInPhi) < nTTInABAlongPhi;
        iTTPhi = mod(++iTTPhi, nTTInPhi)){
      files[iAB] << ttFlags[iTTEta][iTTPhi];
    }
    files[iAB] << "\n";
      }
      files[iAB] << "#\n";
      //writeEventTrailer(files[iAB], nTTInABAlongPhi);
    }
  }  
}

void  fillABSRPFiles(const char barrelSrFlags[nBarrelTTInEta][nTTInPhi],
             const char endcapSrFlags[nEndcaps][nSupercrystalXBins]
             [nSupercrystalYBins],
             ofstream files[nAB]){
  //event headers:
  for(int iAB=0; iAB < nAB; ++iAB){
    files[iAB] << "# Event " << iEvent << "\n";
  }
  
  bool lineAppended[nAB];
  for(int i=0; i< nAB; lineAppended[i++]=false)/*empty*/;
  
  //EE:
  for(int iEE = 0; iEE < nEndcaps; ++iEE){
    for(int iX = 0; iX < nSupercrystalXBins; ++iX){
      for(int iY=0; iY < nSupercrystalYBins; ++iY){
    //        int iDCC = dccIndex(iEE==0?0:2,iX*5,iY*5);
    int iDCC = dccIndexOfRU(iEE==0?0:2,iX,iY);
    if(iDCC>=0){
      int iAB = abOfDcc(iDCC);
      if(!lineAppended[iAB]){
        for(int i=0; i< iY; ++i) files[iAB] << ' ';
      }
      files[iAB] << srp2roFlags[(int)endcapSrFlags[iEE][iX][iY]];
      lineAppended[iAB] = true;
    }
      }//next iY
      for(int iFile=0; iFile< nAB; ++iFile){
    if(lineAppended[iFile]){
      files[iFile] << "\n";
      lineAppended[iFile] = false;
    }
      }
    }//next iX
  }
  
  //EB:
  for(int iABEta=1; iABEta<3; ++iABEta){
    for(int iABPhi=0; iABPhi<nABInPhi; ++iABPhi){
      int iAB = abNum(iABEta,iABPhi);
      int iTTPhiMin;
      int iTTPhiMax;
      getABTTPhiBounds(iABPhi, iTTPhiMin, iTTPhiMax);
      //writeEventHeader(files[iAB], iEvent, nTTInABAlongPhi);
      for(int i = 0 ; i <= iTTEtaMax[iABEta]-iTTEtaMin[iABEta];
      ++i){
    int iTTEta;
    if(iTTEtaSign[iABEta]>0){
      iTTEta = iTTEtaMin[iABEta] + i;
    } else{
      iTTEta = iTTEtaMax[iABEta] - i;
    }
    for(int iTTPhi = iTTPhiMin;
        mod(iTTPhiMax-iTTPhi,nTTInPhi) < nTTInABAlongPhi;
        iTTPhi = mod(++iTTPhi, nTTInPhi)){
      files[iAB] << srp2roFlags[(int)barrelSrFlags[iTTEta-nEndcapTTInEta][iTTPhi]];
    }
    files[iAB] << "\n";
      }
      //      writeEventTrailer(files[iAB], nTTInABAlongPhi);
      files[iAB] << "#\n";
    }
  }

  //file trailers
  for(int iAB=0; iAB < nAB; ++iAB){
    files[iAB] << "#\n";
  }
}

void  fillABIOFiles(const char ttFlags[nTTInEta][nTTInPhi],
            const char barrelSrFlags[nBarrelTTInEta][nTTInPhi],
            const char endcapSrFlags[nEndcaps][nSupercrystalXBins][nSupercrystalYBins],
            ofstream files[]){
  for(int iABEta=0; iABEta < nABInEta; ++iABEta){
    for(int iABPhi=0; iABPhi < nABInPhi; ++iABPhi){
      int iAB = abNum(iABEta, iABPhi);
      //      writeABIOFileHeader(files[iAB], iAB);
      files[iAB] << "# Event " << iEvent << "\n"; 
      //TCC inputs:
      for(int iTCC=0; iTCC< nABTCCCh; ++iTCC){
    files[iAB] << "ITCC" << iTCC+1 << ":"
           << getABTCCInputStream(ttFlags, iABEta, iABPhi, iTCC)
           << "\n";
      }
      //AB inputs:
      for(int iABCh=0; iABCh<nABABCh; ++iABCh){
    files[iAB] << "IAB" <<  iABCh+1 << ":"
           << getABABInputStream(ttFlags, iABEta, iABPhi, iABCh)
           << "\n";
      }
      //AB outputs:
      for(int iABCh=0; iABCh<nABABCh; ++iABCh){
    files[iAB] << "OAB" <<  iABCh+1 << ":"
           << getABABOutputStream(ttFlags, iABEta, iABPhi, iABCh)
           << "\n";
      }
      //DCC output:
      for(int iDCCCh=0; iDCCCh<nDCCCh; ++iDCCCh){
    files[iAB] << "ODCC";
    files[iAB]<< (iDCCCh<=8?"0":"") << iDCCCh+1 << ":"
          << getABDCCOutputStream(barrelSrFlags, endcapSrFlags, iABEta, iABPhi,iDCCCh)
          << "\n";
      }
      files[iAB] << "#\n";
    }
  }
}

/*
  stringstream filename;
  filename.str("");
  filename << abTTFFilePrefix << abNum(iABEta, iABPhi) <<abTTFFilePostfix;
  ofstream file(filename.str(), ios::ate);

*/

bool readTTF(FILE* f, char ttFlags[nTTInEta][nTTInPhi]){
  char* buffer = NULL;
  size_t bufferSize = 0;
  int read;
  if(f==NULL) exit(EXIT_FAILURE);
  int line=0;
  int iEta = 0;
  while(iEta<nTTInEta && (read=getline(&buffer, &bufferSize,f))!=-1){
    ++line;
    char* pos = buffer;
    while(*pos==' ' || *pos=='\t') ++pos; //skip spaces
    if(*pos!='#' && *pos!='\n'){//not a comment line nor an empty line
      if(read-1!=nTTInPhi){
    cerr << "Error: line " << line
         << " of file "<< ttfFilename << " has incorrect length"
      //             << " (" << read-1 << " instead of " << nTTInPhi << ")"
         << endl;
    exit(EXIT_FAILURE);
      }
      for(int iPhi=0; iPhi<nTTInPhi; ++iPhi){
    ttFlags[iEta][iPhi] = buffer[iPhi];
    //         if(ttFlags[iEta][iPhi]!='.'){
    //           cout << __FILE__ << ":" << __LINE__ << ": "
    //                << iEta << "," << iPhi
    //                << " " << ttFlags[iEta][iPhi] << "\n";
    //         }
      }
      ++iEta;
    }
  }
  //returns true if all TT were read (not at end of file)
  return (iEta==nTTInEta)?true:false;
}

bool readSRF(FILE* f,
         char barrelSrFlags[nBarrelTTInEta][nTTInPhi],
         char endcapSrFlags[nEndcaps][nSupercrystalXBins]
         [nSupercrystalYBins]){
  char* buffer = NULL;
  size_t bufferSize = 0;
  int read;
  if(f==NULL) exit(EXIT_FAILURE);
  int line=0;
  int iEta = 0;
  int iXm = 0;
  int iXp = 0;
  int iReadLine = 0;//number of read line, comment lines excluded
  //number of non-comment lines to read:
  const int nReadLine = nBarrelTTInEta + nEndcaps*nSupercrystalXBins; 
  while(iReadLine<nReadLine && (read=getline(&buffer, &bufferSize,f))!=-1){
    ++line;
    char* pos = buffer;
    while(*pos==' ' || *pos=='\t') ++pos; //skip spaces
    if(*pos!='#' && *pos!='\n'){//not a comment line nor an empty line
      //go back to beginning of line:
      pos = buffer;
      if(iReadLine<nSupercrystalXBins){//EE- reading
    if(read-1!=nSupercrystalYBins){
      cerr << "Error: line " << line
           << " of file "<< srfFilename << " has incorrect length"
           << " (" << read-1 << " instead of " << nSupercrystalYBins << ")"
           << endl;
      exit(EXIT_FAILURE);
    }
    for(int iY=0; iY<nSupercrystalYBins; ++iY){
      endcapSrFlags[0][iXm][iY] = buffer[iY];
    }
    ++iXm;
      } else if(iReadLine<nSupercrystalYBins+nBarrelTTInEta){//EB reading
    if(read-1!=nTTInPhi){
      cerr << "Error: line " << line
           << " of file "<< srfFilename << " has incorrect length"
           << " (" << read-1 << " instead of " << nTTInPhi << ")"
           << endl;
      exit(EXIT_FAILURE);
    }
    for(int iPhi=0; iPhi<nTTInPhi; ++iPhi){
      barrelSrFlags[iEta][iPhi] = buffer[iPhi];
    }
    ++iEta;
      } else if(iReadLine<2*nSupercrystalXBins+nBarrelTTInEta){ //EE+ reading
    if(read-1!=nSupercrystalYBins){
      cerr << "Error: line " << line
           << " of file "<< srfFilename << " has incorrect length"
           << " (" << read-1 << " instead of " << nSupercrystalYBins << ")"
           << endl;
      exit(EXIT_FAILURE);
    }
    for(int iY=0; iY<nSupercrystalYBins; ++iY){
      endcapSrFlags[1][iXp][iY] = buffer[iY];
    }
    ++iXp;
      }
      ++iReadLine;      
    }//not a comment or empty line
  }
  //returns 0 if all TT were read:
  return (iReadLine==nReadLine)?true:false;
}


// void writeEventHeader(ofstream& f, int iEvent, int nPhi){
//   //event header:
//   stringstream header;
//   header.str("");
//   header << " event " << iEvent << " ";
//   f << "+";
//   for(int iPhi = 0; iPhi < nPhi; ++iPhi){
//     if(iPhi == (int)(nPhi-header.str().size())/2){
//       f << header.str();
//       iPhi += header.str().size()-1;
//     } else{
//       f << "-";
//     }
//   }
//   f << "+\n";
// }

// void writeEventTrailer(ofstream& f, int nPhi){
//   f << "+";
//   for(int iPhi = 0; iPhi < nPhi; ++iPhi) f << "-";
//   f << "+\n";
// }

void writeABTTFFileHeader(ofstream& f, int abNum){
  time_t t;
  time(&t);
  const char* date = ctime(&t);
  f << "# TTF flag map covered by AB " << abNum+1 <<"\n#\n"
    "# Generated on : " << date << "#\n"
    "# +---> Phi          " << srpFlagMarker[0] << ": 000 (low interest)\n"
    "# |                  " << srpFlagMarker[1] << ": 001 (single)\n"     
    "# |                  " << srpFlagMarker[2] << ": 010 (neighbour)\n"    
    "# V |Eta|            " << srpFlagMarker[3] << ": 011 (center)\n"     
    "#\n";
}

void writeABSRFFileHeader(ofstream& f, int abNum){
  time_t t;
  time(&t);
  const char* date = ctime(&t);
  const char* xLabel;
  const char* yLabel;
  if(abNum<3 || abNum>8){//endcap
    xLabel = "Y  ";
    yLabel = "X    ";
  } else{//barrel
    xLabel = "Phi";
    yLabel = "|Eta|";
  }
  f << "# SRF flag map covered by AB " << abNum+1 <<"\n#\n"
    "# Generated on : " << date << "#\n"
    "# +---> " << xLabel << "          " << roFlagMarker[0] << ": 000 (suppress)\n"          
    "# |                  "              << roFlagMarker[1] << ": 010 (SR Threshold 2)\n"     
    "# |                  "              << roFlagMarker[2] << ": 001 (SR Threshold 1)\n"     
    "# V " << yLabel << "            "   << roFlagMarker[3] << ": 011 (Full readout)\n"     
    "#\n"
    "# action table (when forced):\n"
    "# LI-> " << roFlagMarker[actions[0]] << " (" << roFlagMarker[actions[4]]<< ")" << "\n"
    "# S -> " << roFlagMarker[actions[1]] << " (" << roFlagMarker[actions[5]]<< ")" << "\n"
    "# N -> " << roFlagMarker[actions[2]] << " (" << roFlagMarker[actions[6]]<< ")" << "\n"
    "# C -> " << roFlagMarker[actions[3]] << " (" << roFlagMarker[actions[7]]<< ")" << "\n";
}

void writeABIOFileHeader(ofstream& f, int abNum){
  time_t t;
  time(&t);
  const char* date = ctime(&t);
  f << "# AB " << abNum+1 <<" I/O \n#\n"
    "# Generated on : " << date << "#\n"
    "# " << srpFlagMarker[0] << ": 000 (low interest)   " << tccFlagMarker[0] << ": 000 (low interest)   " << roFlagMarker[0] << ": 000 (suppress)\n"
    "# " << srpFlagMarker[1] << ": 001 (single)         " << tccFlagMarker[1] << ": 001 (mid interest)   " << roFlagMarker[1] << ": 010 (SR Threshold 2)\n"
    "# " << srpFlagMarker[2] << ": 010 (neighbour)      " << tccFlagMarker[2] << ": 010 (not valid)      " << roFlagMarker[2] << ": 001 (SR Threshold 1)\n"   
    "# " << srpFlagMarker[3] << ": 011 (center)         " << tccFlagMarker[3] << ": 011 (high interest)  " <<   roFlagMarker[3] << ": 011 (Full readout)\n"
    "#\n"
    "# action table (when forced):\n"
    "# LI-> " << roFlagMarker[actions[0]] << " (" << roFlagMarker[actions[4]]<< ")" << "\n"
    "# S -> " << roFlagMarker[actions[1]] << " (" << roFlagMarker[actions[5]]<< ")" << "\n"
    "# N -> " << roFlagMarker[actions[2]] << " (" << roFlagMarker[actions[6]]<< ")" << "\n"
    "# C -> " << roFlagMarker[actions[3]] << " (" << roFlagMarker[actions[7]]<< ")" << "\n"
    "#\n"; 
}

string getFlagStream(const char flags[nTTInEta][nTTInPhi], int iEtaMin,
             int iEtaMax, int iPhiMin, int iPhiMax){
  assert(0<=iEtaMin && iEtaMin<=iEtaMax && iEtaMax<nTTInEta);
  if(iEtaMin<=nTTInEta/2 && iEtaMax>nTTInEta){
    cerr << "Implementation Errror:"
     << __FILE__ << ":" << __LINE__ 
     << ": A flag stream cannot covers parts of both half-ECAL!"
     << endl;
    exit(EXIT_FAILURE);
  }

  bool zPos = (iEtaMin>=nTTInEta/2);

  stringstream buffer;
  buffer.str("");
  for(int jEta = 0; jEta <= iEtaMax-iEtaMin; ++jEta){
    //loops on iEta in |eta| increasing order:
    int iEta;
    if(zPos){
      iEta = iEtaMin + jEta;
    } else{
      iEta = iEtaMax - jEta;
    }

    for(int iPhi = mod(iPhiMin,nTTInPhi);
    mod(iPhiMax+1-iPhi,nTTInPhi) != 0;
    iPhi = mod(++iPhi, nTTInPhi)){
      buffer << flags[iEta][iPhi];
    }
  }
  
  return buffer.str();
}

string getABTCCInputStream(const char tccFlags[nTTInEta][nTTInPhi],
               int iABEta, int iABPhi, int iTCCCh){
  //gets eta bounds for this tcc channel:
  int iTCCEta;
  if(iABEta==1 || iABEta==2){//barrel
    if(iTCCCh>5) return ""; //only 6 TCCs per AB for barrel
    iTCCEta =  1 + iABEta;
  } else{//endcap
    if(iABEta==0){//EE-
      iTCCEta = (iTCCCh<6)?1:0;
    } else{//EE+
      iTCCEta = (iTCCCh<6)?4:5;
    }
  }      
  int iEtaMin = iTCCEtaBounds[iTCCEta];
  int iEtaMax = iTCCEtaBounds[iTCCEta+1]-1;

  //gets phi bounds:
  int iPhiMin;
  int iPhiMax;
  getABTTPhiBounds(iABPhi, iPhiMin, iPhiMax);
  //phi is increasing with TTC channel number
  //a TTC covers a 4TT-wide phi-sector
  //=>iPhiMin(iTTCCh) = iPhiMin(AB) + 4*iTTCCh for iTCCCh<6 
  iPhiMin += 4*(iTCCCh%6);
  iPhiMax = iPhiMin + 4 - 1;
  
  return getFlagStream(tccFlags, iEtaMin, iEtaMax, iPhiMin, iPhiMax);
}

string getABABOutputStream(const char tccFlags[nTTInEta][nTTInPhi],
               int iABEta, int iABPhi, int iABCh){
  stringstream buffer;
  buffer.str("");
  bool barrel = (iABEta==1 || iABEta==2); //true for barrel, false for endcap
  switch(iABCh){
  case 0:
    //to AB ch #0 are sent the 16 1st TCC flags received on TCC input Ch. 0
    buffer << getABTCCInputStream(tccFlags, iABEta, iABPhi, 0).substr(0,16);
    break;
  case 1:
    //to AB ch #1 are sent the 16 1st TCC flags received on TCC input Ch. 0 to 5:
    for(int iTCCCh=0; iTCCCh<6; ++iTCCCh){
      buffer <<
    getABTCCInputStream(tccFlags, iABEta, iABPhi, iTCCCh).substr(0,16);
    }
    break;
  case 2:
    //to AB ch #2 are sent the 16 1st TCC flags received on TCC input Ch. 5:
    buffer << getABTCCInputStream(tccFlags, iABEta, iABPhi, 5).substr(0,16);
    break;
  case 3:
    //to AB ch #3 are sent TCC flags received on TCC input Ch. 0 and 6:
    buffer << getABTCCInputStream(tccFlags, iABEta, iABPhi, 0);
    buffer << getABTCCInputStream(tccFlags, iABEta, iABPhi, 6);
    break;
  case 4:
    //to AB ch #4 are sent TCC flags received on TCC input Ch 5 and 11:
    buffer << getABTCCInputStream(tccFlags, iABEta, iABPhi, 5);
    buffer << getABTCCInputStream(tccFlags, iABEta, iABPhi, 11);
    break;
  case 5:
    //for endcaps AB output ch 5 is not used.
    //for barrel, to AB ch #5 are sent the 16 last TCC flags received on TCC
    //input Ch. 0:
    if(barrel){//in barrel
      string s = getABTCCInputStream(tccFlags, iABEta, iABPhi, 0);
      assert(s.size()>=16);
      buffer << s.substr(s.size()-16,16);
    }
    break;
  case 6:
    //for endcaps AB output ch 6 is not used.
    //for barrel, to AB ch #6 are sent the 16 last TCC flags received on TCC
    //input Ch. 0 to 5:
    if(barrel){//in barrel
      for(int iTCCCh=0; iTCCCh<6; ++iTCCCh){
    string s = getABTCCInputStream(tccFlags, iABEta, iABPhi, iTCCCh); 
    buffer << s.substr(s.size()-16,16);
      }
    }
    break;
  case 7:
    //for endcaps AB output ch 7 is not used.
    //for barrel, to AB ch #7 are sent the 16 last TCC flags received on TCC
    //input Ch. 5:
    if(barrel){//in barrel
      string s = getABTCCInputStream(tccFlags, iABEta, iABPhi, 5);
      assert(s.size()>=16);
      buffer << s.substr(s.size()-16,16);
    }
    break;
  default:
    assert(false);
  }
  return buffer.str();
}

string getABABInputStream(const char tccFlags[nTTInEta][nTTInPhi], int iABEta, 
              int iABPhi, int iABCh){
  int iAB = abNum(iABEta, iABPhi);
  int iOtherAB; //AB which this channel is connected to
  int iOtherABCh; //ch # on the other side of the AB-AB link
  abConnect(iAB,iABCh,iOtherAB,iOtherABCh);
  int iOtherABEta = iOtherAB/3;
  int iOtherABPhi = iOtherAB%3;
  return getABABOutputStream(tccFlags, iOtherABEta, iOtherABPhi, iOtherABCh);
}


void getABTTPhiBounds(int iABPhi, int& iTTPhiMin, int& iTTPhiMax){
  iTTPhiMin = mod(-6+iABPhi*nTTInABAlongPhi,nTTInPhi);
  iTTPhiMax = mod(iTTPhiMin+nTTInABAlongPhi-1, nTTInPhi);
}

void abConnect(int iAB,int iABCh,int& iOtherAB,int& iOtherABCh){
  static bool firstCall = true;
  static int xconnectMap[nAB][nABABCh][2];
  if(firstCall){
    FILE* f = fopen(xconnectFilename, "r");
    if(f==NULL){
      cerr << "Error. Failed to open xconnect definition file,"
       << xconnectFilename << endl;
      exit(EXIT_FAILURE);
    }
    //skips two first lines:
    for(int i=0; i<2; ++i){
      int c;
      while((c=getc(f))!='\n' && c >=0);
    }
    int ilink = 0 ;
    while(!feof(f)){
      int abIn;
      int pinIn;
      int abOut;
      int pinOut;
      if(4==fscanf(f, "%d\t%d\t%d\t%d", &abIn, &pinIn, &abOut, &pinOut)){
    xconnectMap[abIn][pinIn][0] = abOut;
    xconnectMap[abIn][pinIn][1] = pinOut;
    ++ilink;
      }
    }
    if(ilink!=nAB*nABABCh){
      cerr << "Error cross-connect definition file " << xconnectFilename
       << " contains an unexpected number of link definition."
       << endl;
      exit(EXIT_FAILURE);
    }
    firstCall = false;
  }

  iOtherAB = xconnectMap[iAB][iABCh][0];
  iOtherABCh = xconnectMap[iAB][iABCh][1];
}

string getABDCCOutputStream(const char barrelSrFlags[nBarrelTTInEta][nTTInPhi],
                const char endcapSrFlags[nEndcaps][nSupercrystalXBins]
                [nSupercrystalYBins],
                int iABEta, int iABPhi, int iDCCCh){
  bool barrel = (iABEta==1||iABEta==2);
  if(barrel){
    //same as TCC with same ch number but with TCC flags replaced by SRP flags:
    string stream = getABTCCInputStream(barrelSrFlags-nEndcapTTInEta, iABEta, iABPhi, iDCCCh);
    //converts srp flags to readout flags:
    for(size_t i=0; i< stream.size(); ++i){
      stream[i] = srp2roFlags[(int)stream[i]];
    }
    return stream;
  } else{//endcap
    if(iDCCCh<3){//used DCC output channel
      //endcap index:
      int iEE=(iABEta==0)?0:1;
      stringstream buffer("");
      //3 DCC per AB and AB DCC output channel in
      //increasing DCC phi position:
      int iDCCPhi = iABPhi*3+iDCCCh;
      for(size_t iSC=0; iSC < ecalDccSC[iEE][iDCCPhi].size(); ++iSC){
    pair<int,int> sc = ecalDccSC[iEE][iDCCPhi][iSC];
    buffer << srp2roFlags[(int)endcapSrFlags[iEE][sc.first][sc.second]];
      }
      return buffer.str();
    } else{//unused output channel
      return "";
    }
  }
}