/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/tools/Toolbox.cpp

Go to the documentation of this file.

/* @version $Revision: 1773 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2012-06-13 10:20:21 +0200 (Wed, 13 Jun 2012) $ */


#include <sstream>
#include <iostream>
#include <map>
#include <string>
#include <set>
#include <sstream>

#include "tools/MicroException.hh"
#include "tools/Toolbox.hh"
#include "XMLTool.hh"
#include "Log.hh"
#include "Detector.hh"
#include "Mysql.hh"


#include <iostream>
#include <fstream>


#include <stdlib.h>
#include <errno.h>




using namespace std;


Toolbox::Toolbox()
{
}


Toolbox::~Toolbox()
{
}

//////////////////////////////////////////////////////////////////////////////////////
void Toolbox::printRepere ( bool xRotation, bool yRotation, int zRotation ) 
{
  cout <<" \n ------------- ROTATIONS" << endl;

  int result = (xRotation== false) ? 0 : 180; 
  cout <<  "### xRotation " << result << " degree." <<  endl;

  result = (yRotation== false) ?  0 : 180;
  cout <<  "### yRotation " << result <<  " degree." << endl;

  cout <<  "### zRotation " << zRotation << " degree." << endl;
  

  cout << endl << "### Nous utilisons un repere irthonorme directe ###" <<endl;
  cout << "" << endl;
  cout << "                                             X" << endl;
  cout << "                                              " << endl;
  cout << "                                             ^" << endl;
  cout << "                                            / \\ " << endl;
  cout << "                                             |" << endl;
  cout << "                                             |" << endl;
  cout << "                                             |" << endl;
  cout << "                                             |" << endl;
  cout << "                                             |" << endl;
  cout << "                                             |" << endl;
  cout << "SYSTEM de COORDONNEES: (0,0) au centre   ----X---------->  Y     " << endl;
  cout << "  Z rentrant.                                |" << endl;
  cout << "                                             |" << endl;
  cout << "                                             |" << endl;
  cout << "                                             |" << endl;

}


////////////////////////////////////////////////////////////////////////////////////
/////    FUCNTION TO CONVERT big indian to little indian
//////////////////////////////////////////////////////////////////////////////////////
unsigned short Toolbox::bigTolittle ( short value )
{

unsigned short lsb =  value  & MASK_LSB  ;
    lsb = lsb << 8 ;

    unsigned short msb =  value & MASK_MSB;
    msb = msb >> 8 ;



    unsigned short result = lsb + msb;
    return result;
}

//------------------------------------------------------------------------------------
void Toolbox::addFloatToString(std::string& chaine, float value)
{

        std::string s;
        std::stringstream out;
        out << value;
        s = out.str();
        chaine = chaine.append(s);
}
//------------------------------------------------------------------------------------
void Toolbox::addIntToString(std::string& chaine, int value)
{

        std::string s;
        std::stringstream out;
        out << value;
        s = out.str();
        chaine = chaine.append(s);
}

//------------------------------------------------------------------------------------
void Toolbox::readSteerFile(string steerName , bool debug = false)
{

FILE *steerFile;
  

  // Get command parameter : here steering file
  cout << "Steering File: " << steerName << endl;

  // Get steering parameters
  steerFile=fopen(steerName.data(),"r");

  // --- Number of input DATA files ---
  int nbOfFile = 0;
  fscanf (steerFile, "%d", &nbOfFile);
  if ( debug ) cout << "Nb input data file(s)\t" << nbOfFile << endl;

  // --- DATA Files Names ---
  string fileNam[nbOfFile];
  for ( int i = 0 ; i < nbOfFile ; i++  ) 
  {
        fscanf (steerFile, "%s",fileNam[i].data());
        if ( debug ) cout << "input data file " << i << " \t" << fileNam[i].data() << endl;
  }

  // --- ROOT Files Name ---
  string rootFileName;
  fscanf (steerFile, "%s", rootFileName.data());
  if ( debug ) cout << "root file name \t\t" << rootFileName.data() << endl;

  // --- VERBOSE MODE ---
  string verbose;
  fscanf (steerFile, "%s",verbose.data());
  if ( debug ) cout << "verbose Mode\t\t" << verbose.data() << endl;

  // ---  Nmicro = Number of MicroMegas Chambers ---
  int Nmicro = 0;
  fscanf (steerFile, "%d", &Nmicro);
  if ( debug ) cout << "Nb of MicroMegas Chambers  " <<Nmicro<< endl;

  // --- NGplex[i] = Number of Gassiplex card for MicroMegas "i" ---
  int NGplex[Nmicro];
  // --- NTotGplex = TOTAL Nb of Gassiplex Cards ---
  int NTotGplex = 0;
  for ( int i = 0 ; i < Nmicro ; i++  ) 
    {
      fscanf (steerFile, "%d", &NGplex[i]);
      if ( debug ) cout << "Nb of Gassiplex Cards for MicroMegas no="<<i<< "   " <<NGplex[i]<< endl;
      if ( debug ) cout << "Nb of Channels        for MicroMegas no="<<i<< "   " <<NGplex[i]*96<< endl;
      NTotGplex += NGplex[i];    }
  if ( debug ) cout << "TOTAL Nb of Gassiplex Cards  " << NTotGplex << endl;

  // --- Nchamber[GplCount] = ID of MicroMegas for gassiplex nb "GplCount"
  unsigned int Nchamber[NTotGplex];
  int GplCount=-1;
  for ( int i = 0 ; i < Nmicro ; i++  ) 
    {
      for ( int j = 0 ; j < NGplex[i] ; j++  )
        {
          GplCount++;
          Nchamber[GplCount]=i;// ID of MicroMegas for gassiplex "GplCount"
          if ( debug ) cout << "ID of MicroMegas for gassiplex nb" << GplCount << " : " << Nchamber[GplCount]<<endl;
        }
    }
 
  
  fclose (steerFile);
  float d=3; //distance between chambers, should be entered by steering file
  int nBeta2=0;
  int nBeta24=0;
  for(int i=0;i<Nmicro;i++){if(NGplex[i]==1){nBeta2++;}else{nBeta24++;}}
  if ( debug ) cout<<nBeta2<<" chambres beta 2\n"
      <<nBeta24<<" chambres beta 2.4\n";

  if ( strcmp(verbose.data(),"-v") == 0 ) { verbose = true; }
  if ( debug ) cout << "Verbose mode\t\t\t\t" << verbose << endl;


        
}


/**********************************************************************/
// display a binary number
std::ostream& operator <<(std::ostream &out, const BinOut& x) {
//  out << "0x" << hex << x._Num << dec << "=";
  //out << HexOut(x._Num, 2) << "=";
  for (unsigned int digit = x._Digits; digit > 0; digit--) {
    if ((digit != x._Digits) && (digit % 4 == 0))
      out << " ";
    out << ((x._Num >> (digit - 1)) & 0x1);
  }
  return(out);
} // BinOut.operator <<


/**********************************************************************/
// Method get unique name and create with mode read/write and permissions 0666 
// User must then call unlink
string Toolbox::getTempFileName(void)
{
  
  FILE *sfp = NULL;
  int fd = -1;
  char sfn[22] = "";
  strncpy(sfn, "/tmp/micromegas.XXXXXX", sizeof sfn);
  if ((fd = mkstemp(sfn)) == -1 )
  {
    unlink(sfn);
    close(fd);
    fprintf(stderr, "%s: %s\n", sfn, strerror(errno));
    throw MicroException("Cannot create temporaly file");
  }
 
  string result = sfn;
  return result;
}

/**********************************************************************/
bool Toolbox::getDetector(ui32 runId,Detector &detector)
{
  Mysql mysql;
  MYSQL_ROW row;

  string detectorXMLValue = mysql.getDetectorStringFromRunId(runId) ;


  string fileName = Toolbox::getTempFileName();



  for (unsigned  int i = 0 ; i < detectorXMLValue.size(); i++ )
  {
    if( detectorXMLValue[i] == '\r' ) detectorXMLValue[i] = ' ';
  }

  ofstream myfile;
  myfile.open (fileName.c_str());
  myfile << "<micromegas xmlns:run=\"http://lappweb.in2p3.fr/LC\">" ;
  myfile << detectorXMLValue + "\n" ;
  myfile << "</micromegas>" ;
  myfile.close();

  SteerDesc steerDesc;
  XMLTool xml;
  xml.parse(steerDesc, fileName); // parse steer file and fill steerDesc

  //Detector detector;
  if ( ! detector.build(steerDesc) == steerDesc.chambers.size() )
  {
    FILE_LOG(logERROR) << "Geometry Error. Please check your XML file."  << endl;
    return false;
  }


  unlink(fileName.c_str());
  return true;
}

---