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

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

#include "dataManager.h"
#include "mathematicalConstants.h"
#include "PhysicalConstants.h"
#include "softwareUnknown.h"

#include "GWt_pspaApplication.h"
#include "GWt_console.h"
#include "GWt_ligneFaisceau.h" // FIXME to be removed !

#include <boost/filesystem.hpp>

#include "UAP/UAPUtilities.hpp"
#include "AML/AMLReader.hpp"
#include "AMLtools.h"

#define BAVARD 1

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

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

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

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();
  indexElementToIndexDiag_.clear();
  // for (unsigned int a=0; a< jobList_.size(); a++) {
  //     jobList_[a]->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()
{
#if BAVARD > 0
  cout << "***********************************" << endl;
  cout << " dataManager::executeAll() " << endl << endl;
#endif

  bool success = true;
  string workingDir = pspa_->getWorkingDir();
  
  // Main loop !
  cout << " dataManager::executeAll #sectors_= " << sectors_.size() << endl;
  //  expandedMachine machine;
  //  machine.fromJoblist(jobList_);

  // vecteur de blocs de calcul 
  vector<computingBlock*> compblock = getCurrentMachine()->getComputingBlocks();
  cout << " dataManager::executeAll() : nb blocs de calcul : " << compblock.size() << endl;

  particleBeam* computedBeam = sectors_[0]->getParticleBeam();


  //  for(unsigned k = 0; k < jobList_.size(); k++) 
  // {
      // sector* sector = jobList_[k];
      // cout << " dataManager::executeAll sector name= " << sector->getName() << endl;
      // cout << " dataManager::executeAll #sectionsToExecute= " << sector->getSectionsToExecute().size() << endl;
      
      // for the moment, we put everything in one line without loops
      //      for(unsigned int l = 0; l < sector->getSectionsToExecute().size(); l++) 
      for (unsigned int l = 0; l < compblock.size(); l++) 
        {
          abstractSoftware* softw = compblock.at(l)->getSoftware();
          cout << " execution du SOFWARE " << softw->getName() << endl;
          if (softw == NULL) {
            success = false;
            consoleMessage("dataManager::executeAll : unknown software");
            break;
          }
    
          //      success = softw->createInputFile(sector->getParticleBeam(),workingDir);
          cout << " dataManager::executeAll() APPEL softw->createInputFile " << endl;
          success = softw->createInputFile(computedBeam,workingDir);
          if ( success ) {
            success = softw->execute(workingDir);
            if ( success ) {
              success = softw->buildBeamAfterElements(workingDir);
            }
          }
          cout << " dataManager::executeAll success = " << success << " y-a-ty du faisceau : " << diagnosticBeam_.size() << endl;
          if ( success  && (diagnosticBeam_.size() > 0)) {
            // sector->setParticleBeam(&diagnosticBeam_.at(indexElementToIndexDiag_.back()));
            computedBeam = &diagnosticBeam_.at(indexElementToIndexDiag_.back());
            cout << " dataManager::executeAll termine avec succes " << endl;
          } else {
            //      sector->setParticleBeam(NULL);
            computedBeam = NULL;
            cout << " dataManager::executeAll termine en ECHEC " << endl;
          }
          if ( !success ) break;
    
#if BAVARD > 0
          cout << "dataManager::executeAll #diagnosticBeam= " << diagnosticBeam_.size() << endl;
          //      cout << "dataManager::executeAll #getBeamLineSize()= " << getBeamLineSize() << endl;
          //      std::vector< abstractElement* > elements = section->getElements();
          //      std::vector< abstractElement* > elements = compblock.at(l)->getElements();
          for (unsigned j = 0; j < compblock.at(l)->getNumberOfElements(); j++) {
            cout << "[" << j << "] " << compblock.at(l)->getElement(j)->getNomdElement().getExpandedName() << endl;
          }
#endif
        } //l
      //    } //k
  
  // if ( currentBeam_deprecated_ ) {
  // string aml_file = workingDir + "/" + "faisceau_final" + ".aml";
  //   currentBeam_deprecated_->writeToAMLFile(aml_file);
  //   // TESTS
  //   currentBeam_deprecated_->readFromAMLFile(aml_file);
  // }
 
  return success;
}

// void dataManager::saveConfiguration(string folder, string nameOfFile)
// {
//   ofstream outfile;
//   //string name = pspa_->getWorkingDir()+ folder + "/" + nameOfFile + ".save";
//   cout << " dataManager::saveConfiguration : suppression du folder dans le nom de " << endl;
//   cout << " sauvegarde, en attendant que ce soit autre chose que le sessionId" << endl;
//   cout << " et qu'on puisse restaurer normalement" << endl;

//   string name = pspa_->getWorkingDir() + "/" + 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();

//   // FIXME Francois: Comment sauver la configuration des section ?
//   for (unsigned int a=0; a< jobList_.size(); a++) {
//     outfile << jobList_[a]->getSectorParameters().FileOutputFlow();
//   }
//   // END
  
//   abstractElement* elPtr;
//   for (unsigned k = 0; k < jobList_.size(); k++) {
//     sector* sector = jobList_[k];
//     for (unsigned l = 0; l < sector->getSectionsToExecute().size(); l++) {
//       sectionToExecute* section = sector->getSectionsToExecute()[l];
//       for (unsigned m = 0; m < section->getElements().size(); m++) {
//         elPtr = section->getElements()[m];
//         outfile << elPtr->FileOutputFlow();
//       }
//     }
//   }
//   outfile.close();
// }






// ecriture sur fichier AML
void dataManager::writeToAMLFile(string fileName)
{
  UAPNode* uap_root = NULL;
  uap_root = new UAPNode("UAP_root");
  UAPNode* rep = uap_root->addChild("AML_representation");
  
  // root node in the hierarchy
  UAPNode* lab = rep->addChild("laboratory");
  lab->addAttribute("name","PSPA lab");
  
  // general global parameters--docroot . --http-address 0.0.0.0 --http-port 8077
  globParam_.InputRep(lab);
  
  // accelerator or section of accelerator
  //UAPNode* acc = lab->addChild("machine");
  //acc->addAttribute("name",fileName);

  //sectorParam_.InputRep(lab);

  // sequence of sectors with elements

  for ( unsigned k=0; k < sectors_.size(); k++) {
    sector* secteur = sectors_.at(k);
    UAPNode* sect = lab->addChild("sector");
    sect->addAttribute("name",secteur->getName());
    abstractElement* elPtr;
    for ( unsigned j=0; j < secteur->getElements().size(); j++) {
      elPtr = secteur->getElements().at(j);
      elPtr->InputRep(sect);
    }
  }

  if ( currentMachine_ ) currentMachine_->FileAMLOutput(lab);
  cout << "!Create the AML file ---------------------------" << endl;
  AMLReader reader;
  string aml_file = pspa_->getWorkingDir() + "/" + fileName + ".aml";
  reader.AMLRepToAMLFile (uap_root, aml_file);
}


bool dataManager::restoreAMLElements(string inputFileName)
{
  cout << "***********************************" << endl;
  cout << " dataManager::restoreAMLElements() fichier :" << inputFileName << endl << endl;

  AMLReader reader;
  UAPNode* uap_root = NULL;
  uap_root = reader.AMLFileToAMLRep (inputFileName);
  if ( !uap_root ) {
    cout << " dataManager::restoreAMLElements ERREUR AML lecture fichier  " << inputFileName << endl;
    return false;
  }

  else cout << " successful opening  : " << inputFileName << " UAP_ROOT= " << uap_root->getName() << endl;
  UAPNode* uap_labname = NULL;

NodeVec laboratories = uap_root->getSubNodesByName(string("laboratory"));
// cout << " dataManager::restoreAMLElements nombre de <laboratory> : " << laboratories.size() << endl;

 uap_labname = *laboratories.begin();

 if ( !uap_labname ) {
   cout << " dataManager::restoreAMLElements : fichier non conforme, on ne trouve pas <laboratory...> " << endl;
   // } else {
   //   cout << " dataManager::restoreAMLElements : GO !" << endl;
 }


  //NOTE:: je ne sais pas si les "secteurs" seront conservés, aussi pour ne pas trop changer les fichiers je lis les données aprÚs "globals" dans la boucle 
  
  // Clear the BeamLine
  sectors_.clear();

  // FIXME : For test purpose !!!
  //  sector* mySect = addNewSector();
  //  if (  currentMachine_ ) delete currentMachine_;
  //  currentMachine_ = new expandedMachine();

   UAPNode* parametresGlobaux = uap_labname->getChildByName(string("global"));
  if ( !parametresGlobaux ) {
    cout << " dataManager::restoreAMLElements GLOBAUX NON TROUVES " << endl;
  // } else {
  //   cout << " dataManager::restoreAMLElements GENIAL ! " << endl;
  }
  globParam_.raz();
  globParam_.FileAMLInput(parametresGlobaux);



  nomdElements::typedElement elementType;
  string elementLabel;


  NodeVec sectorNode = uap_root->getSubNodesByName(string("sector"));

  if ( !sectorNode.size() ) {
    cout << " dataManager::restoreAMLElements ERREUR lecture fichier : pas de sectors ? " << endl;
    return false;
  }
  for (NodeVecIter iterSect = sectorNode.begin(); iterSect != sectorNode.end(); iterSect++) {
    UAPAttribute* att = (*iterSect)->getAttribute("name");
    if ( !att ) continue;
    sectors_.push_back( new sector(this, att->getValue()) );
    NodeVec& listElem = (*iterSect)->getChildren();
    if (  !listElem.size() ) {
      cout << " dataManager::restoreAMLElements WARNING lecture fichier secteur " <<  att->getValue() << "  : pas d'elements ? " << endl;
    }
    abstractElement* nouveau = NULL;
    for (NodeVecIter iterelem = listElem.begin(); iterelem != listElem.end(); iterelem++) {

      string nomNoeud = (*iterelem)->getName();
      if ( nomNoeud != string("element") ) {
        cout << " le secteur contient un non-element : " << nomNoeud << endl;
        continue;
      }

      att = NULL;
      att = (*iterelem)->getAttribute("name");


      string nomGenerique;
      AMLtools::readAMLParameterAttribut(*iterelem, "description", "type", nomGenerique);
      elementType = nomdElements::getTypeFromLabel(nomGenerique);
      nouveau = sectors_.back()->addElementAfter(elementType,nouveau);
      if ( nouveau == NULL ) {
        cerr << " dataManager::restoreAMLElements() : restore element " << att->getValue() << " failed " << endl;
        return false;
      } else {
        nouveau->FileAMLInput(*iterelem); 
      }
    } // iterelem
  } // itersect


  // cout << " dataManager::restoreAMLElements BILAN DES SECTEURS " << endl;
  // for ( unsigned m=0; m < sectors_.size(); m++ ) {
  //   cout << " secteur " << m+1 << " nom : " << sectors_.at(m)->getName() << endl;
  //   for ( unsigned j=0; j<sectors_.at(m)->getElements().size(); j++) {
  //     cout << " el. : " << sectors_.at(m)->getElements().at(j)->getLabel() << endl;
  //   }
  // }

  NodeVec machine = uap_root->getSubNodesByName(string("machine"));
  if ( !machine.size()  ) {
    cout << " dataManager::restoreAMLElements ne trouve pas de machine " << endl;
  } else {
    if ( machine.size() > 1 ) {
      cout << " dataManager::restoreAMLElements PLUSIEURS MACHINES : cas non prevu " << endl;
    }
    //    cout << " dataManager::restoreAMLElements il y a une machine a lire dans   " << endl;
    //    cout << currentMachine_ << endl;
    if ( !currentMachine_ ) currentMachine_ = new expandedMachine(this);
    currentMachine_->FileAMLInput(machine.at(0)); 
  }
  


  return true;
}


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

particleBeam* dataManager::getDiagnosticBeam_deprecated(string elementLabel)
{
  if ( !currentMachine_ ) return NULL;

  // FIXME : Devra etre changé par une récupération par "abstractElement" et non pas par label
  unsigned int number = 0;
  abstractElement* elPtr;

  for (unsigned k = 0; k < currentMachine_->getComputingBlocks().size(); k++) {
    computingBlock* block = currentMachine_->getComputingBlocks().at(k);
    for (unsigned m = 0; m < block->getNumberOfElements(); m++) {
      elPtr = block->getElement(m);
      if (elPtr->getLabel() == elementLabel) {
        return getDiagnosticBeam(number);
      }
      number ++;
    }
  }


  return NULL;
}


void dataManager::donneesRmsEnveloppe(string type,vector<double>& xcor,vector<double>& ycor, string& titre, string& legendx, string& legendy)
{
  double longueur = 0.0;
  double valeur = 0.0;
  xcor.clear();
  ycor.clear();
  titre.clear();
  titre = " rms enveloppe ";
  legendx.clear();
  legendx = " z (m)";
  if ( type == "x" ) {
    unsigned i = 0;
    cout << " dataManager::donneesRmsEnveloppe " << endl;

    if ( !currentMachine_ ) {
    cout << " dataManager::donneesRmsEnveloppe PAS DE MACHINE " << endl;
    return;
    }

  for (unsigned k = 0; k < currentMachine_->getComputingBlocks().size(); k++) {
    computingBlock* block = currentMachine_->getComputingBlocks().at(k);
    for (unsigned m = 0; m < block->getNumberOfElements(); m++) {
      abstractElement* elPtr = block->getElement(m);
      particleBeam* beamToDraw = getDiagnosticBeam(i);
      if ( !beamToDraw->momentRepresentationOk() ) {
        beamToDraw->buildMomentRepresentation();
      }
          
      longueur += elPtr->getLenghtOfElement();
      valeur = beamToDraw->getXmaxRms();
      cout << " dataManager::donneesRmsEnveloppe index = " << k <<  " longueur = " << longueur << " enveloppe : " << valeur << endl;
      xcor.push_back(0.01*longueur);  // on passe en metres
      ycor.push_back(valeur);
      i++;      
    }
  }




    // for (unsigned k = 0; k < jobList_.size(); k++) {
    //   sector* sector = jobList_[k];
    //   for (unsigned l = 0; l < sector->getSectionsToExecute().size(); l++) {
    //     sectionToExecute* section = sector->getSectionsToExecute()[l];
    //     for (unsigned m = 0; m < section->getElements().size(); m++) {
    //       abstractElement* elPtr = section->getElements()[m];
    //       //     if(elPtr->getNomdElement().getElementType() == snapshot) continue;
    //       //      if(elPtr->getNomdElement().getElementType() == fit) continue;
    //       particleBeam* beamToDraw = getDiagnosticBeam(i);
    //       if ( !beamToDraw->momentRepresentationOk() ) {
    //         beamToDraw->buildMomentRepresentation();
    //       }
          
    //       longueur += elPtr->getLenghtOfElement();
    //       valeur = beamToDraw->getXmaxRms();
    //       cout << " dataManager::donneesRmsEnveloppe index = " << k <<  " longueur = " << longueur << " enveloppe : " << valeur << endl;
    //       xcor.push_back(0.01*longueur);  // on passe en metres
    //       ycor.push_back(valeur);
    //       i++;
    //     }
    //   }
    // }

    legendy.clear();
    legendy = " x (cm) ";
  }
}



sector* dataManager::addNewSector() {
  std::stringstream str;
  str << getSectors().size()+1;
  std::string result;
  str >> result;
  
  sector* sect = new sector(this, std::string("sector ") + result);
  sectors_.push_back(sect);
  return sect;
}

abstractElement* dataManager::getElementInSectorsByLabel(string etiq) {
  for ( unsigned k=0; k < sectors_.size(); k++) {
    for ( unsigned j=0; j < sectors_.at(k)->getElements().size(); j++) {
      if ( etiq == sectors_.at(k)->getElements().at(j)->getLabel() ) return sectors_.at(k)->getElements().at(j);
    }
  }
  return NULL;
}


  void dataManager::messageEcran(string niveau, string msg) const {
    GWt_dialog::iconType icon;
    if ( niveau == "ERROR" ) {
      icon = GWt_dialog::Error;
    } else if  ( niveau == "WARNING" ) {
      icon = GWt_dialog::Warning;
    } else if  ( niveau == "INFO" ) {
      icon = GWt_dialog::Info;
    } else {
      icon = GWt_dialog::NoIcon;
    }
    GWt_dialog checkConfigNameDialog(niveau, msg, icon,true,true);
    checkConfigNameDialog.exec();
  }