/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/slowControl/SlowControlManager.cpp

Go to the documentation of this file.

/* @version $Revision: 1764 $ * @modifiedby $Author: lcdet $ * @lastmodified $Date: 2012-06-07 16:58:43 +0200 (Thu, 07 Jun 2012) $ */

#include <map>



#include "slowControl/SlowControlEntry.hh"
#include "slowControl/DriftParams_t.hh"
#include "slowControl/MeshParams_t.hh"
#include "slowControl/PMParams_t.hh"
#include "slowControl/SCSteerParams.hh"
#include "slowControl/BoardSlowControl.hh"
#include "slowControl/PMSlowControl.hh"
#include "slowControl/SlowControlManager.hh"

#include "tools/MicroException.hh"
#include "tools/SteerDesc.hh"
#include "tools/Log.hh"

#include <iostream>
#include <fstream>
#include <iomanip>



using namespace std;

//---------------------------------------------

///////////////////////////////////////////////////////////////////////////////
// SLOW CONTROL CLASS
SlowControlManager::SlowControlManager()
{
  //FILE_LOG(logDEBUG1) << "-SlowControlManager contructor"<< endl;

}

//---------------------------------------------
SlowControlManager::~SlowControlManager()
{
}

//---------------------------------------------
// build the reading structure from steerfile description
void SlowControlManager::build(const SteerDesc& sd) {
  for (int paramNum = 0 ; paramNum < sd.slowControls.size(); paramNum++) {
    const SlowControl_t& p = sd.slowControls[paramNum];
    addSteer(p.scId, p.type, p.chamberId,p.difId,p.boardId,p.pmId, p.name);

  }
}

//---------------------------------------------
void SlowControlManager::addEntry(const SlowControlEntry& entry) {

    genList.insert(entry);
}

//---------------------------------------------
const SlowControlEntry* SlowControlManager::getEntry(const double aTimeStamp)const  {

    // if searched timestamp > at first elelement  20000 ms ( the bigger one ) -> return

 std::set<SlowControlEntry>::const_iterator p = genList.begin();
 if ( aTimeStamp > p->getTimeStamp() + 20000 )
 {
    FILE_LOG(logWARNING) << " p->getTimeStamp() + 20000: " << fixed <<  p->getTimeStamp() + 20000 << endl;
    FILE_LOG(logWARNING) << " aTimeStamp: " << fixed <<  aTimeStamp << endl;
    throw MicroException("SlowControlManager : timestamp upper than max timestamp + 20000 ms:");
 }

int index = 0;
  for (p = genList.begin(); p != genList.end()  ; p++)
  {

index++;

  //cout  << setprecision(20) << "p->getTimeStamp()[" << p->getTimeStamp()  << "]" << endl;
    if (aTimeStamp >= p->getTimeStamp() && p != genList.begin() )  // la valeur recherche doit etre plus grande que la valeur du slowcontrol mais il ne faut pas que se sot la premiere valeur du slowcontrol
    {
         return(&(*p));
    }
  }
  //cout << "aTimeStamp[" << setprecision(20) << aTimeStamp  << "]" << endl;
  throw MicroException("SlowControlManager : timestamp not found:");
}

//---------------------------------------------
// 
const BoardSlowControl& SlowControlManager::getBoard(const double timeStamp, const ui32 chamberId,  const ui32 difId,  const ui32 boardId)const   {
    try 
    {
      return this->getEntry(timeStamp)->getBoard(chamberId, difId, boardId);
    }
    catch (MicroException e)
    {
        throw MicroException("SlowControlManager : timestamp not found:");
    }

}

//---------------------------------------------
i32 SlowControlManager::readDB(string path)
{
  i32 nLines = 0;

  ifstream inFile(path.c_str(), ifstream::in);

  FILE_LOG(logDEBUG1) << "reading Slow Control data base" << endl;
  while (inFile.good()) {
    SlowControlEntry params;  // temporary data for storage
    params.setTimeStamp(-1);
    for (std::list<SCSteerParams>::iterator sp = stList.begin(); sp != stList.end(); sp++) {

      FILE_LOG(logDEBUG1) << " reading " << sp->type 
                          << " chamberId " << sp->chamberId 
                          << " difId " << sp->difId 
                          << " boardId " << sp->boardId 
                          << " pmId " << sp->pmId 
                          << " [" << sp->name << "]" << endl;

      if (sp->type == TIMESTAMP) {
        double foo = 0;
        inFile >> foo;
        params.setTimeStamp(foo);
        FILE_LOG(logDEBUG1) << " timestamp           " << fixed << params.getTimeStamp() << endl;
      }
      else if (sp->type == TEMPERATURE) {
        float foo = 0; 
        inFile >> foo;
        params.setTemperature(foo);
        FILE_LOG(logDEBUG1) << " temperature " << fixed << params.getTemperature() << endl;
      }
      else if (sp->type == PRESSURE) {
        float foo = 0; 
        inFile >> foo;
        params.setPressure(foo);
        FILE_LOG(logDEBUG1) << " pressure " << fixed << params.getPressure() << endl;
      }
      else if (sp->type == OVERPRESSURE) {
        float foo = 0; 
        inFile >> foo;
        params.setOverPressure(foo);
        FILE_LOG(logDEBUG1) << " overPressure " << fixed << params.getOverPressure() << endl;
      }
      else if (sp->type == BOARD) {
        DriftParams_t drift(inFile);
        MeshParams_t mesh(inFile);
        try {
          // may be dummy data
          BoardSlowControl boardSC(sp->name,sp->chamberId, sp->difId, sp->boardId);
          boardSC.setParams(mesh,drift);
          params.setBoardParams(sp->chamberId, sp->difId, sp->boardId,boardSC);

          FILE_LOG(logDEBUG1) << "chamberId "  << sp->chamberId << " board " << sp->boardId << " : t=" << fixed << params.getTimeStamp() << ", drift " << drift << ", mesh " << mesh << endl;
        }
        catch (MicroException& e) {
          FILE_LOG(logERROR) << "board id " << sp->boardId << "difId "  << sp->difId << "chamberId "  << sp->chamberId << " and name[" <<  sp->name << "] not found " << endl;
        }
      }
      else if (sp->type == PM) {
        PMParams_t voltages(inFile);
        try {
//cout << sp->name << ", " <<  sp->pmId << endl;
          PMSlowControl sc(sp->name , sp->pmId);
          sc.setParams(voltages);
          params.setPmParams(sp->pmId,sc);
          FILE_LOG(logDEBUG1) << " PM : t=" << fixed << params.getTimeStamp() << ", pm " << voltages <<  endl;
        }
        catch (MicroException& e) {
          FILE_LOG(logERROR) << "PM id " << sp->pmId << " [" << sp->name << "] not found " << endl;
        }
      }


      if (!inFile.good()) {
        break;
      }
      nLines++;
    } // for

    if (params.getTimeStamp() > 0)
      addEntry(params);
  }

  inFile.close();
  FILE_LOG(logINFO) << " found " << nLines << " slowcontrol inputs" << endl;


  FILE_LOG(logINFO) << "Slowcontrol data base read successfully" << endl;
  return 1;
}

//--------------------------------------------------------------------------------
void SlowControlManager::addSteer(const ui32 scId, const std::string type, const ui32 chamberId,  const ui32 difId,  const ui32 boardId, const ui32 pmId,  const std::string name)
              { stList.push_back(SCSteerParams(scId, type, chamberId, difId, boardId, pmId,  name)); };


//--------------------------------------------------------------------------------

---