/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_13_patch3/src/Calibration/Tools/src/matrixSaver.cc

Go to the documentation of this file.

#include <fstream>
#include <iostream> // for any std::cout
#include <iomanip>  // to print nicely formatted
#include <string>
#include <map>
#include <memory>
//#include <iterator>
#include <cassert>

#include "CLHEP/Matrix/GenMatrix.h"
#include "CLHEP/Matrix/Matrix.h"
#include "CLHEP/Matrix/Vector.h"

#include "Calibration/Tools/interface/matrixSaver.h"

matrixSaver::matrixSaver ()
{
//   std::cout << "[matrixSaver][ctor] matrixSaver instance" << std::endl ;
}


matrixSaver::~matrixSaver ()
{
//   std::cout << "[matrixSaver][dtor] destroyed" << std::endl ;
}


std::ostream &
operator<< (std::ostream& outputFile,
            const CLHEP::HepGenMatrix *saveMe)
{

  int numRow = saveMe->num_row () ;
  int numCol = saveMe->num_col () ;

  // write out the matrix dimensions
  outputFile << numRow << '\t'
                 << numCol << '\n' ;

  // write the elements in the file
  for (int row=0 ; row<numRow ; ++row)
    {
            for (int col=0 ; col<numCol ; ++col)
        {
                                                assert (row < numRow) ;
            assert (col < numCol) ;
                  outputFile << (*saveMe)[row][col] << '\t' ;
        }
            outputFile << '\n' ;
    }

   return outputFile ;
}



int
matrixSaver::saveMatrix (std::string outputFileName,
                        const CLHEP::HepGenMatrix *saveMe)
{
   // open the output file
   std::fstream outputFile (outputFileName.c_str (), std::ios::out) ;
   assert (outputFile) ;
 
   int numRow = saveMe->num_row () ;
   int numCol = saveMe->num_col () ;

   // write out the matrix dimensions
   outputFile << numRow << '\t'
                  << numCol << '\n' ;

   outputFile << saveMe ;

   return 0 ;

}


int
matrixSaver::saveMatrixVector (std::string filename,
                               const std::vector<CLHEP::HepGenMatrix *> &saveMe)
{
     typedef std::vector<CLHEP::HepGenMatrix*>::const_iterator const_iterator ;
     // open the output file
     std::fstream outputFile (filename.c_str (), std::ios::out) ;
     assert (outputFile != NULL) ;

     // save the number of elements of the vector
     outputFile << saveMe.size ()       
                << '\n' ;

     // save the matrix sizes
     outputFile << (*saveMe.begin ())->num_row ()
                << '\t'
                << (*saveMe.begin ())->num_col ()
                << '\n' ;

     // loop over the vector
     for (const_iterator it = saveMe.begin () ;
               it != saveMe.end () ;
               ++it)
       {
               outputFile << (*it) ;
       } // loop over the vecor

     return 0 ;
}


std::istream &
operator>> (std::istream& input, CLHEP::HepGenMatrix &matrix)
{
  int numRow = 0 ;
  int numCol = 0 ;
  
  //PG read the matrix dimension
  input >> numRow ;
  input >> numCol ;
  
  //PG check whether the matrices have the right dimension
  assert ( numRow == matrix.num_row () ) ;
  assert ( numCol == matrix.num_col () ) ;

  //PG get the matrix elements from the file
  for (int row=0 ; row<numRow ; ++row)
    {
      for (int col=0 ; col<numCol ; ++col)
              {
                input >> matrix[row][col] ;
            assert (col*row < numRow*numCol) ;
              } 
    }   

  return input ;
}


int matrixSaver::touch (std::string inputFileName)
{
   std::fstream inputFile (inputFileName.c_str (), std::ios::in) ;
   return (inputFile != NULL) ;
}



CLHEP::HepGenMatrix *
matrixSaver::getMatrix (std::string inputFileName)
{
     //PG open the output file
     std::fstream inputFile (inputFileName.c_str (), std::ios::in) ;
     if (inputFile == NULL) std::cerr << "file: " << inputFileName << std::endl ;
     assert (inputFile != NULL) ;

     //PG get the matrix dimensions
     int numRow = 0 ;
     int numCol = 0 ;
     inputFile >> numRow ;
     inputFile >> numCol ;

     //PG instantiate the matrix
     CLHEP::HepGenMatrix * matrix ;
     if (numCol > 1)
             matrix = new CLHEP::HepMatrix (numRow, numCol, 0) ;
     else
             matrix = new CLHEP::HepVector (numRow, 0) ;

     inputFile >> *matrix ;

     return matrix ;
}


std::vector<CLHEP::HepGenMatrix*> *
matrixSaver::getMatrixVector (std::string inputFileName)
{
     // open the output file
     std::fstream inputFile (inputFileName.c_str (), std::ios::in) ;
     assert (inputFile != NULL) ;

     // get the vector length
     int numElem = 0 ;
     inputFile >> numElem ;
     
     // get the matrix dimensions
     int numRow = 0 ;
     int numCol = 0 ;
     inputFile >> numRow ;
     inputFile >> numCol ;

     //PG prepara il vector
     std::vector<CLHEP::HepGenMatrix*>* matrixVector = 
       new std::vector<CLHEP::HepGenMatrix*> (numElem) ;
          
     //PG loop sugli elementi del vettore
     for (int i=0 ; i<numElem ; ++i)
       {
          //PG definisce il puntatore
          CLHEP::HepGenMatrix * matrix ;
          //PG attribuisce un oggetto concreto

          if (numCol > 1)
                  matrix = new CLHEP::HepMatrix (numRow, numCol, 0) ;
          else
                  matrix = new CLHEP::HepVector (numRow, 0) ;
          
          //PG scarica su un oggetto concreto
          inputFile >> *matrix ;

          //PG riempie il vettore
          (*matrixVector)[i] = matrix ;
       }

     return matrixVector ;
}


std::vector<CLHEP::HepMatrix> 
matrixSaver::getConcreteMatrixVector (std::string inputFileName)
{
     // open the output file
     std::fstream inputFile (inputFileName.c_str (), std::ios::in) ;
     assert (inputFile != NULL) ;

     // get the vector length
     int numElem = 0 ;
     inputFile >> numElem ;
     
     // get the matrix dimensions
     int numRow = 0 ;
     int numCol = 0 ;
     inputFile >> numRow ;
     inputFile >> numCol ;

     //PG prepara il vector
     std::vector<CLHEP::HepMatrix> matrixVector (
         numElem,
         CLHEP::HepMatrix (numRow,numCol,0)
       ) ;
     
     //PG loop sugli elementi del vettore
     for (int i=0 ; i<numElem ; ++i)
       {
          
          //PG scarica su un oggetto concreto
          inputFile >> matrixVector[i] ;

       }

     return matrixVector ;
}