source: PSPA/Interface_Web/trunk/pspaWT/sources/controler/src/dataManager.cc @ 355

#include "dataManager.h"
#include "mathematicalConstants.h"
#include "PhysicalConstants.h"
#include "softwareParmela.h"
#include "softwareTransport.h"
#include "GWt_pspaApplication.h"
#include "GWt_console.h"
#include "softwareGenerator.h"
#include "softwareTest.h"

#include <boost/filesystem.hpp>
#include <stdio.h>
#include <fstream>

dataManager::dataManager(PspaApplication* pspa) :
  currentBeam_(NULL),
  pspa_ (pspa)
{}

dataManager::~dataManager() 
{
  unsigned k;
  for (k=0; k < jobList_.size();k++) {
    if ( jobList_[k] != NULL ) delete jobList_[k];
  }
  if ( currentBeam_ == NULL ) delete currentBeam_;
}

void dataManager::consoleMessage(string message) {
  GWt_console* console = static_cast<GWt_console*> (wApp->findWidget ("console"));
  if (console) console->addConsoleMessage(message);
  pspa_->processEvents();
}

string dataManager::getLabelFromElementNumero(int numero)
{
    abstractElement* ptr = pspa_->getBeamLine()->getAbstractElement(numero-1);
    if ( ptr == NULL ) return "";
    return ptr->getLabel();
}


int dataManager::getNumeroFromElementLabel(string label)
{
  int index = -1;
  
  for (int k = 0; k < getBeamLineSize() ; k++)
    {
      if (pspa_->getBeamLine()->getAbstractElement(k) != NULL){
        if ( pspa_->getBeamLine()->getAbstractElement(k)->getLabel() == label )
          {
            index = (int)k + 1;
            return index;
          }
      }
    }
  return index;
}


abstractElement* dataManager::getElementPointerFromNumero(int k)
{
  return pspa_->getBeamLine()->getAbstractElement(k-1);
}


void dataManager::addSectionToExecute(int debut, int fin, nomDeLogiciel prog)
{
  jobList_.push_back(new sectionToExecute);
  jobList_.back()->firstElement = debut;
  jobList_.back()->lastElement = fin;
  jobList_.back()->software  = prog;
}

void dataManager::clearSectionToExecute()
{
  unsigned k;
  for(k = 0; k < jobList_.size(); k++)
    {
      if ( jobList_[k] != NULL ) delete jobList_[k];
    }
  jobList_.clear();
}

trivaluedBool dataManager::checkExecute(string& diagnostic)
{
  cout << "dataManager::checkExecute()" << endl;
  consoleMessage(" VERIFICATION AVANT EXECUTION ");
  
  trivaluedBool resul = ok;
  diagnostic.clear();
  
  for(unsigned k = 0; k < jobList_.size(); k++) {
    
    unsigned numeroDeb = jobList_[k]->firstElement;
    unsigned numeroFin = jobList_[k]->lastElement;
    
    if ( numeroFin  < numeroDeb ) {
      diagnostic += " last element before first for job " + (jobList_[k]->software).getString() + " \n";
      resul = error;
      break;
    }

    string checkCompatibility;
    resul = checkElementsForExec(jobList_[k]->software,numeroDeb,numeroFin,checkCompatibility);
    diagnostic += checkCompatibility;
  } //k

  return resul;
}

trivaluedBool dataManager::checkElementsForExec(nomDeLogiciel logiciel,unsigned numeroDeb,unsigned numeroFin,string& diagnostic)
{
  trivaluedBool resul = ok;
  trivaluedBool accepted;

  diagnostic.clear();  
  abstractElement* elPtr;

  for(unsigned j = numeroDeb; j <= numeroFin; j++) {
    elPtr = pspa_->getBeamLine()->getAbstractElement(j-1);
    accepted = elPtr->is_accepted_by_software(logiciel);

    if(accepted == error) {
      diagnostic += " the element " + elPtr->getNomdElement().getElementName() + " is not allowed with " + logiciel.getString() + " \n";
      resul = error;
    } else if (accepted  == warning) {
      diagnostic += " the element " + elPtr->getNomdElement().getElementName() + " will be ignored by " + logiciel.getString() + " \n";
      if ( resul != error ) resul = warning;
    }
  }

  return resul;
}

void dataManager::initializeExecution()
{
  string workingDir = pspa_->getWorkingDir();
    if (workingDir == "") {
        return;
    }
    removeFile(workingDir + "parmdesz");
    removeFile(workingDir + "parmin");
    removeFile(workingDir + "parin.input0");
    removeFile(workingDir + "transport.input");
    removeFile(workingDir + "transport.output");
    removeFile(workingDir + "generator.in");
    removeFile(workingDir + "faisceau.ini");
    removeFile(workingDir + "generator.output");
    diagnosticBeam_.clear();
    currentBeam_ = NULL;
    clearSectionToExecute();
}

void dataManager::removeFile(string nameOfFile)
{
    ifstream fileExists;
    fileExists.open(nameOfFile.c_str(), ios::in);
    if (fileExists) {
        fileExists.close();
        remove(nameOfFile.c_str());
    }
}

bool dataManager::executeAll()
{
  bool success = true;
  abstractSoftware* softw = NULL;
  string workingDir = pspa_->getWorkingDir();

  for(unsigned k = 0; k < jobList_.size(); k++)
    { 
      cout << " dataManager::executeAll je m'apprete a executer : " << (jobList_[k]->software).getString() << endl;
      
      int debut = jobList_[k]->firstElement;
      int fin = jobList_[k]->lastElement;
      softw = createSoftwareConnexion(jobList_[k]->software);
      
      if (softw == NULL) {
        success = false;
        consoleMessage("dataManager::executeAll : unknown software");
        break;
      }

      success = softw->createInputFile(currentBeam_,debut,fin,workingDir);
      if ( success ) {
        success = softw->execute(debut,fin,workingDir);
        if ( success ) {
          success = softw->buildBeamAfterElements(debut,fin,diagnosticBeam_,workingDir);
        }
      }
      
      delete softw;
      if ( success ) {
        currentBeam_ = &diagnosticBeam_.back();
        cout << " execute termine avec succes " << endl;
      } else {
        currentBeam_ = NULL;
        cout << " execute termine en ECHEC " << endl;
      }
      if ( !success ) break;
  
      //debug
      cout << "dataManager::executeAll #diagnosticBeam= " << diagnosticBeam_.size() << endl;
      cout << "dataManager::executeAll #getBeamLineSize()= " << getBeamLineSize() << endl;
      for (int j = debut; j <= fin; j++) {
        abstractElement* elPtr= getElementPointerFromNumero(j);
        cout << "[" << j << "] " << elPtr->getNomdElement().getElementName() << endl;
      } 

    } //k
  
  return success;
}

void dataManager::saveConfiguration(string folder, string nameOfFile)
{
    ofstream outfile;
    string name = pspa_->getWorkingDir()+ folder + "/" + nameOfFile + ".save";

    // make dir if not exist
    boost::filesystem::create_directories(pspa_->getWorkingDir() + folder + "/");
    
    outfile.open(name.c_str(), ios::out);
    if (!outfile) {
        cerr << " error opening output file for persistency " << name << endl;
    }
  
  outfile << globParam_.FileOutputFlow();
  abstractElement* elPtr;
  for(unsigned k = 0; k < getBeamLineSize() ; k++)
    {
      elPtr = pspa_->getBeamLine()->getAbstractElement(k);
      outfile << elPtr->FileOutputFlow();
    }
  outfile.close();
}

bool dataManager::restoreElements( string inputFileName)
{
    cout << "dataManager::restoreElements() fichier " << inputFileName << endl;
    ifstream infile;
    string name = inputFileName;
    infile.open(name.c_str(), ios::in);
    if (!infile) {
        cerr << " error opening input stream " << name << endl;
        return false;
    }
    else cout << " successful opening input stream " << name << endl;
    
    string globalTitle;
    if ( infile >> globalTitle ) {
        if ( globalTitle == string("globals") ) {
            globParam_.raz();
            globParam_.FileInput(infile);
        } else {
            cerr << " dataManager::restoreElements ERROR : global parameters seems to be missing" << endl;
            return false;
        }
    } else {
        cerr << " dataManager::restoreElements ERROR : reading data save file" << endl;
        return false;
    }
    
    pspa_->getBeamLine()->clear();
    
    typedElement elementType;
    string elementLabel;
    while (infile >> elementLabel) {
        elementType = nomdElements::getTypeFromLabel(elementLabel);
        
        GWt_abstractElement* nouveau = pspa_->getBeamLine()->addElement(elementType);
        
        if ( nouveau == NULL ) {
            cerr << " dataManager::restoreElements ERROR : restoring element " << elementLabel << " failed " << endl;
            return false;
        }
        nouveau->FileInput(infile);
    }
    infile.close();

    // debug
    // unsigned k;
    // for(k = 0; k < getBeamLineSize(); k++) {
    //     abstractElement* ptr = pspa_->getBeamLine()->getAbstractElement(k);        
    //     cout << "reupere " << ptr->getLabel() << endl;
    // }
    return true;
}

particleBeam* dataManager::getDiagnosticBeam(unsigned index)
{
  if (index >= diagnosticBeam_.size()) {
    return NULL;
  } else {
    return &diagnosticBeam_.at(index);
  }
}

// void dataManager::donneesRmsEnveloppe(string type,unsigned int numeroDeb,unsigned int numeroFin, vector<double>& xcor,vector<double>& ycor)
// {
//   unsigned k;
//   if ( numeroDeb < 1 ) numeroDeb = 1;
//   if ( numeroFin > diagnosticBeam_.size() ) numeroFin = diagnosticBeam_.size();
        
//   double longueur = 0.0;
//   double valeur = 0.0;
//   xcor.clear();
//   ycor.clear();
//   if ( type == "x" )
//     {
//       for (k= numeroDeb; k <= numeroFin; k++)
//         {
//        if ( !diagnosticBeam_.at(k-1).momentRepresentationOk() ) diagnosticBeam_.at(k-1).buildMomentRepresentation();
//        longueur += pspa_->getBeamLine()->getAbstractElement(k-1)->getLenghtOfElement();
//        valeur = diagnosticBeam_.at(k-1).getXmaxRms();
//        cout << " dataManager::donneesRmsEnveloppe longueur = " << longueur << " enveleloppe : " << valeur << endl;
//        xcor.push_back(longueur);
//        ycor.push_back(valeur);
//         }
//     }
//   else
//     {
//       cerr << " dataManager::donneesRmsEnveloppe type " << type << " not programmed " << endl;
//       return;
//     }
// }

// on ne tient pas compte des elements "snapshot" presents dans la beamLine
void dataManager::donneesRmsEnveloppe(string type,vector<double>& xcor,vector<double>& ycor)
{
  double longueur = 0.0;
  double valeur = 0.0;
  xcor.clear();
  ycor.clear();

  if ( type == "x" ) {
    unsigned i = 0;
    cout << " dataManager::donneesRmsEnveloppe BeamLineSize = " << getBeamLineSize() << endl;
    for (unsigned k = 0; k < getBeamLineSize(); k++) {
      abstractElement* elPtr = pspa_->getBeamLine()->getAbstractElement(k);
      if(elPtr->getNomdElement().getElementType() == snapshot) continue;
      if(elPtr->getNomdElement().getElementType() == fit) continue;

      if ( !diagnosticBeam_.at(i).momentRepresentationOk() ) {
        diagnosticBeam_.at(i).buildMomentRepresentation();
      }

      longueur += elPtr->getLenghtOfElement();
      valeur = diagnosticBeam_.at(i).getXmaxRms();
      cout << " dataManager::donneesRmsEnveloppe index = " << k <<  " longueur = " << longueur << " enveleloppe : " << valeur << endl;
      xcor.push_back(longueur);
      ycor.push_back(valeur);
      i++;
    }
  } else {
    cerr << " dataManager::donneesRmsEnveloppe type " << type << " not programmed " << endl;
    return;
  }
}

int dataManager::getBeamLineSize() {
  return pspa_->getBeamLine()->getBeamLineSize();
}

abstractSoftware* dataManager::createSoftwareConnexion(nomDeLogiciel logi) 
{
  string inputFileName;
  if(logi == nomDeLogiciel::parmela) {
    inputFileName = "parmin";
    return new softwareParmela(inputFileName, &globParam_, this);
  } else if (logi == nomDeLogiciel::transport) {
    inputFileName = "transport.input";
    return new softwareTransport(inputFileName, &globParam_, this);
  } else if (logi == nomDeLogiciel::generator) {
    inputFileName = "generator.in";
    return new softwareGenerator(inputFileName, &globParam_, this);
  } else if (logi == nomDeLogiciel::test) {
    return new softwareTest(inputFileName, &globParam_, this);
  } else {
    return NULL;
  } 
}