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

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

#include <stdio.h>
#include <fstream>
//#include <algorithm>


dataManager::dataManager(PspaApplication* pspa) :
currentBeam_(NULL)
,workingDir_("")
,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_;
}


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;
    unsigned int k;
    
    for (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;
  trivaluedBool resul = ok;
  unsigned k,j;
  diagnostic.clear();
  unsigned numeroDeb, numeroFin;
  cout << "controle execution : " << endl;
  for(k = 0; k < jobList_.size(); k++) {
    numeroDeb = jobList_[k]->firstElement;
    numeroFin = jobList_[k]->lastElement;
    if ( numeroFin  < numeroDeb )
      {
        diagnostic += " last element before first  for job " + (jobList_[k]->software).getString() + " \n";
        resul = error;
        break;
      }
    cout << " numeroDeb= " << numeroDeb << " numeroFin= " << numeroFin << endl;
    // indexDeb--;
    // indexFin--;
    
    abstractElement* elPtr;
    string checkCompatibility;
    resul = checkElementsForExec(jobList_[k]->software, numeroDeb, numeroFin, checkCompatibility);
    diagnostic += checkCompatibility;
  }
  cout << " data manager renvoie resul = " << resul << endl;
  return resul;
}


trivaluedBool dataManager::checkElementsForExec(nomDeLogiciel logiciel, unsigned numeroDeb, unsigned numeroFin, string& diagnostic)
{
    trivaluedBool resul = ok;
    diagnostic.clear();
    trivaluedBool accepted;
    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()
{
    if (workingDir_ == "") {
        return;
    }
    removeFile(workingDir_ + "parmdesz");
    removeFile(workingDir_ + "parmin");
    removeFile(workingDir_ + "transport.input");
    removeFile(workingDir_ + "transport.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(string &resul)
{
    bool success = true;
    resul.clear();
    string resultatPartiel;
    unsigned k;
    abstractSoftware* softw =NULL;
    
    for(k = 0; k < jobList_.size(); k++)
    {
      int debut = jobList_[k]->firstElement;
      int fin = jobList_[k]->lastElement;
      resultatPartiel.clear();
      cout << " dataManager::executeAll je m'apprete a executer : " << (jobList_[k]->software).getString() << endl;

      string inputFileName;
      if(jobList_[k]->software == nomDeLogiciel::parmela) {
        softw = new softwareParmela(&globParam_, this);
        inputFileName = "parmin";
      } else if (jobList_[k]->software == nomDeLogiciel::transport) {
        softw = new softwareTransport(&globParam_, this);
        inputFileName = "transport.input";
      } else if (jobList_[k]->software == nomDeLogiciel::generator) {
        softw = new softwareGenerator(&globParam_, this);
        inputFileName = "generator.in";
      } else {
        success = false;
        resultatPartiel =  " unknown software -- STOP \n ";     
        break;
      }

      success = softw->createInputFile(inputFileName,currentBeam_, debut, fin, workingDir_);
      if ( !success ) {
        resultatPartiel += " error creating input file \n";
      } else {
        success = softw->execute(inputFileName, debut,fin,workingDir_,resultatPartiel);
        if ( success ) {
          success = softw->buildBeamAfterElements(debut, fin, diagnosticBeam_, workingDir_);
          if ( !success ) {
            resultatPartiel += " reading results failed \n";
          }
        }
      }
      delete softw;
      if ( success ) {
        currentBeam_ = &diagnosticBeam_.back();
        cout << " execute termine avec succes " << endl;
      } else {
        currentBeam_ = NULL;
        cout << " execute termine en ECHEC " << endl;
      }
      resul += resultatPartiel;
      if ( !success ) break;
    }
    return success;
}


void dataManager::saveConfiguration( string nameOfFile)
{
    ofstream outfile;
    string name = workingDir_ + nameOfFile + ".save";
    outfile.open(name.c_str(), ios::out);
    if (!outfile) {
        cerr << " error opening output file for persistency " << name << endl;
    }
    
    outfile << globParam_.FileOutputFlow();
    unsigned k;
    abstractElement* elPtr;
    for ( 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 = workingDir_ + inputFileName + ".save";
    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();
            xcor.push_back(longueur);
            ycor.push_back(valeur);
        }
    }
    else
    {
        cerr << " dataManager::donneesRmsEnveloppe type " << type << " not programmed " << endl;
        return;
    }
}

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