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

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

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

abstractElement* dataManager::addElement(typedElement elemType)
{
  return elementsGallery_.addElement(elemType);
}

string dataManager::getLabelFromElementNumero(int numero)
{
  abstractElement* ptr = elementsGallery_.getElementPointerFromNumero(numero);
  if ( ptr == NULL ) return "";
  return ptr->getLabel();
}


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 indexDeb, indexFin;
  cout << "controle execution : " << endl;
  for(k = 0; k < jobList_.size(); k++) {
    indexDeb = jobList_[k]->firstElement;
    indexFin = jobList_[k]->lastElement;
    if ( indexFin  <= indexDeb )
      {
        diagnostic += " first and last elements are the same for job " + (jobList_[k]->software).getString() + " \n";
        resul = error;
        break;
      }
    cout << " indexDeb= " << indexDeb << " indexFin= " << indexFin << endl;
    indexDeb--;
    indexFin--;
    
    abstractElement* elPtr;
    string checkCompatibility;
    resul = checkElementsForExec(jobList_[k]->software, indexDeb, indexFin, checkCompatibility);
    diagnostic += checkCompatibility;
  }
  cout << " data manager renvoie resul = " << resul << endl;
  return resul;
}

trivaluedBool dataManager::checkElementsForExec(nomDeLogiciel logiciel, unsigned indexDeb, unsigned indexFin, string& diagnostic)
{
  trivaluedBool resul = ok;
  diagnostic.clear();
  trivaluedBool accepted;
  abstractElement* elPtr;
  for(unsigned j = indexDeb; j <= indexFin; j++) {
    elPtr = elementsGallery_.getElementPointerFromIndex(j);
    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)
{
  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 workingDir, 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;

      if(jobList_[k]->software == nomDeLogiciel::parmela) {
        softw = new softwareParmela(&globParam_, &elementsGallery_);
      } else if (jobList_[k]->software == nomDeLogiciel::transport) {
        softw = new softwareTransport(&globParam_, &elementsGallery_);
      } else {
        success = false;
        resultatPartiel =  " unknown software -- STOP \n ";     
        break;
      }

      success = softw->createInputFile(currentBeam_, debut, fin, workingDir);
      if ( !success ) {
        resultatPartiel += " error creating input file ";
      } else {
        success = softw->execute(diagnosticBeam_, debut,fin,workingDir,resultatPartiel);
      }
      delete softw;
      if ( success ) currentBeam_ = &diagnosticBeam_.back();
      else currentBeam_ = NULL;
      resul += resultatPartiel;
      if ( !success ) break;
    }
  return success;
}

void dataManager::saveConfiguration(string workingDir, 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 < elementsGallery_.size() ; k++)
    {
      elPtr = elementsGallery_.getElementPointerFromIndex(k);
      outfile << elPtr->FileOutputFlow();
    }
  outfile.close();    
}

bool dataManager::restoreElements(string workingDir, 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;
  }

  elementsGallery_.raz();
  //  typedElement elem;
 typedElement elementType;
  string elementLabel;
  //  while (infile >> ielem) {
  while (infile >> elementLabel) {
    //    elem = (typedElement)ielem;
    //    abstractElement* nouveau = addElement(elem);
    elementType = nomdElements::getTypeFromLabel(elementLabel);
    abstractElement* nouveau = 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 <  elementsGallery_.size(); k++) {
    abstractElement* ptr= elementsGallery_.getElementPointerFromIndex(k);
    cout << "reupere " << ptr->getLabel() << endl;
  }


  return true;
}

particleBeam* dataManager::getDiagnosticBeam(unsigned index) 
{
  cout << " particleBeam* dataManager je vais dessiner " << getLabelFromElementNumero(index+1) << endl;


  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();

  unsigned indexDeb = numeroDeb -1;
  unsigned indexFin = numeroFin -1;

  double longueur = 0.0;
  double valeur = 0.0;
  xcor.clear();
  ycor.clear();
  if ( type == "x" )
    {
      for (k= indexDeb; k <= indexFin; k++)
        {
          if ( !diagnosticBeam_.at(k).momentRepresentationOk() ) diagnosticBeam_.at(k).buildMomentRepresentation();
          longueur += elementsGallery_.getElementPointerFromIndex(k)->getLenghtOfElement();
          valeur = diagnosticBeam_.at(k).getXmaxRms();
          xcor.push_back(longueur);
          ycor.push_back(valeur);
        }
    }
  else
    {
      cerr << " dataManager::donneesRmsEnveloppe type " << type << " not programmed " << endl;
      return;
    }
}