source: PSPA/Interface_Web/trunk/pspaWT/src/dataManager.cc @ 149

#include "dataManager.h"
#include "environmentVariables.h"

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

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

string dataManager::checkExecute()
{
  cout << "dataManager::checkExecute()" << endl;
  
  int k,j;
  string diagnostic;
  int 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 ans last elements are the same \n";
        break;
      }
    cout << " indexDeb= " << indexDeb << " indexFin= " << indexFin << endl;
    indexDeb--;
    indexFin--;
    abstractElement* elPtr;
    if(jobList_[k]->software == nomDeLogiciel::parmela ) 
      {
        for(j = indexDeb; j <= indexFin; j++) {
          elPtr = elementsGallery_.getElementPointer(j);

          cout << "elPtr parmela: " << elPtr->getLabel() << endl;

          if(!elPtr->is_parmela_element()) {
            diagnostic += " the element " + elPtr->getNameString() + " is not allowed for PARMELA \n";
          }
        }           
      }
    else if (jobList_[k]->software == nomDeLogiciel::transport) 
      {
        for(j = indexDeb; j <= indexFin; j++) {
          elPtr = elementsGallery_.getElementPointer(j);

          cout << "elPtr transp: " << elPtr->getLabel() << endl;

          if (!elPtr->is_transport_element()) {
            diagnostic += " the element " + elPtr->getNameString() + " is not allowed for TRANSPORT \n";
          }
        }           
      }
    else 
      {
        diagnostic += (jobList_[k]->software).getString() + " : unknown software \n ";  
      }
  }
  
  return diagnostic;
}

bool dataManager::executeTransport( unsigned int indexDeb, unsigned int indexFin, string& resul)
{
  ostringstream sortie;
  bool success = true;
  resul.clear();
  sortie << " EXECUTION DE TRANSPORT DE " << indexDeb << " a " << indexFin << endl;
  if ( !createInputFileTransport( indexDeb, indexFin) )
    {
          sortie << " error creating transport input file "  << endl;
          resul = sortie.str();
          success = false;
          return success;
    }

  string bufString;
  char buf[132];
  string transportJob = WORKINGAREA + "transport";
  transportJob += string(" <  ");
  transportJob += WORKINGAREA + "transport.input";
  //  transportJob += string(" >  ");
  //  transportJob += WORKINGAREA + "transport.output";
  cout << " job transport= " << transportJob << endl;

      ofstream outfile;
      string nameOut = WORKINGAREA + "transport.output";


  FILE* pp = popen(transportJob.c_str(), "r");
  if (pp != NULL)
    {
      cout << " execution transport MARCHE " << endl;

      ////////////////////////
      outfile.open(nameOut.c_str(), ios::out);
      if (!outfile) 
        {
          sortie << " error first opening transport output stream " << nameOut << endl;
          resul = sortie.str();
          success = false;
          return success;
        }

      unsigned nbl = 0;
      while (fgets(buf, sizeof buf, pp))
        {
          //      cout << " buf= " << buf << endl;
          sortie << buf;
          outfile << buf;
          nbl++;
        }
      outfile.close();
      /////////////////////////////////

      //      cout << " datamanager ecriture output terminee nbl = " << nbl << endl;
      // on re-ouvre le fichier de sortie

      ifstream infile;

      infile.open(nameOut.c_str(), ios::in);
      
      //&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

      int k;
      for ( k= indexDeb; k <= indexFin; k++)
        {
          diagnosticBeam_.push_back(particleBeam());

          string elemLabel = getLabelFromElementNumero (k);
          abstractElement* ptr = elementsGallery_.getElementPointerFromNumero(k);
          bool camarche = diagnosticBeam_.back().setFromTransport(elemLabel, ptr->getName() );
          if (!camarche  )
            {
              sortie << " reading transport output  failed " << endl;
              success = false;
              break;
            }
        }
      currentBeam_ = &diagnosticBeam_.back();
      //&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

      pclose(pp);
      resul =  sortie.str();
    }
  else
    {
      sortie << " launching of transport failed \n";
      resul =  sortie.str();
      success =  false;
    }
  return success;
}

bool  dataManager::executeParmela(unsigned int indexDeb,unsigned int indexFin,string& resul)
{
  bool success = true;
  resul.clear();
  createInputFileParmela(indexDeb,indexFin);

  ostringstream sortie;
  sortie << " EXECUTION DE PARMELA DE l'ELEMENT " << indexDeb << " A L'ELEMENT " << indexFin << endl;

  char buf[132];
  string parmelaJob = WORKINGAREA + "parmela";
  parmelaJob += string("   ");
  parmelaJob += WORKINGAREA;
  cout << " job parmela= " << parmelaJob << endl;
  FILE* pp = popen(parmelaJob.c_str(), "r");
  if (pp != NULL) {
    cout << " execution parmela MARCHE " << endl;
    while (fgets(buf, sizeof buf, pp))
      {
        sortie << buf;
      }

    //      cout << " sortie parmela " << sortie.str() << endl;
    string::size_type nn = (sortie.str()).find("normal");
    if ( nn == string::npos ) 
      {
        sortie << " abnormal exit of parmela " << endl;
        resul =  sortie.str();
        success = false;
        return success;
      }

      int k;
      for ( k= indexDeb; k <= indexFin; k++)
        {
          diagnosticBeam_.push_back(particleBeam());
          if (! diagnosticBeam_.back().setFromParmela(k, globParam_.getFrequency()) )
            {
              sortie << " reading parmdesz  failed " << endl;
              success = false;
              break;
            }
        }
      currentBeam_ = &diagnosticBeam_.back();

      // if ( !currentBeam_->setFromParmela(indexFin, globParam_.getFrequency()) )
      //        {
      //          sortie << " reading parmdesz  failed " << endl;
      //          success = false;
      //        }
      pclose(pp);
      resul =  sortie.str();
    }
  else
    {
      sortie << " launching of parmela failed " << endl;
      resul =  sortie.str();
      success = false;
    }
  
  return success;
}

bool dataManager::createInputFileTransport( unsigned int indexDeb, unsigned int indexFin)
{
  unsigned int k;
  if ( !currentBeam_->momentRepresentationOk() )
    {

      cout << " dataManager::createInputFileTransport : creating moment representation " << endl;
      if ( currentBeam_->particleRepresentationOk() )
        {
          currentBeam_->buildMomentRepresentation();
        }
      else 
        {
          cout << " ca cafouille dans les representations de faisceau " << endl;
          return false;
        }
    }

  indexDeb--;
  indexFin--;

  const vector< vector<double> >& moments = currentBeam_->getTransportMoments();
  double P0 = currentBeam_->getP0Transport();
  ofstream outfile;
  string name = WORKINGAREA + "transport.input";
  outfile.open(name.c_str(), ios::out);
  if (!outfile) 
    {
      cout << " error opening output stream " << name << endl;
      return false;
    }

  outfile << string("'titre provisoire'") << endl;
  outfile << " 0 " << endl;
  outfile << " UTRANS " << endl;

  outfile << " BEAM, X=" << (moments.at(0)).at(0) << ", XP="<< (moments.at(1)).at(1) << ", Y=" << (moments.at(2)).at(2)<< ", YP=" << (moments.at(3)).at(3) << ", & " << endl;

  outfile << " DL=" << (moments.at(4)).at(4) << ", DEL="<< (moments.at(5)).at(5) << ", P0=" << P0 << " ; " << endl;

  outfile << " CORR, C21=" << (moments.at(1)).at(0) << ", C31="<< (moments.at(2)).at(0) << ", C32=" << (moments.at(2)).at(1) << ", & " << endl;

  outfile << " C41=" << (moments.at(3)).at(0) << ", C42="<< (moments.at(3)).at(1) << ", C43=" << (moments.at(3)).at(2) << ", C51=" << (moments.at(4)).at(0) << ", & " << endl;

  outfile << " C52=" << (moments.at(4)).at(1) << ", C53="<< (moments.at(4)).at(2) << ", C54=" << (moments.at(4)).at(3) << ", C61=" << (moments.at(5)).at(0) << ", & " << endl;

  outfile << " C62=" << (moments.at(5)).at(1) << ", C63="<< (moments.at(5)).at(2) << ", C64=" << (moments.at(5)).at(3) << ", C65=" << (moments.at(5)).at(4) << " ; " << endl;
  outfile << " PRINT, BEAM, ON; " << endl;


  abstractElement* elPtr;
  for ( k=indexDeb; k <= indexFin; k++)
    {
      elPtr = elementsGallery_.getElementPointer(k);
      outfile << elPtr->transportOutputFlow() << endl;
    }

  outfile << " SENTINEL " << endl;
  outfile << " SENTINEL " << endl;

  outfile.close();
  return true;
}

void dataManager::createInputFileParmela( unsigned int indexDeb, unsigned int indexFin)
{
  indexDeb--;
  indexFin--;

  ofstream outfile;
  string name = WORKINGAREA + "parmin";
  outfile.open(name.c_str(), ios::out);
  if (!outfile) {
      cerr << " error opening output stream " << name << endl;
  }

  abstractElement* elPtr;
  elPtr = elementsGallery_.getElementPointer(indexDeb);
  if ( elPtr->getName() != initialBeam ) {
      cerr << " dataManager::createInputFileParmela : the first element should be initialBeam" << endl;
    }
  
  unsigned int k;
  double initalKineticEnergy = 0.0;
  for ( k = indexDeb; k <= indexFin; k++)
    {
      if ( elPtr->getName() == initialBeam ) 
        {
          elPtr->setPhaseStep( globParam_.getIntegrationStep() );
          elPtr = elementsGallery_.getElementPointer(k);
          initalKineticEnergy = elPtr->getInitialKineticEnergy();
          break;
        }
    }

  outfile << "TITLE" << endl;
  outfile << " titre provisoire " << endl;
  outfile << "RUN /n0=1 /ip=999 /freq=" << globParam_.getFrequency() << "  /z0=0.0 /W0=" << initalKineticEnergy << "  /itype=1" << endl;
  outfile << "OUTPUT 0" << endl;
    
  for ( k = indexDeb; k <= indexFin; k++)
    {
      elPtr = elementsGallery_.getElementPointer(k);
      outfile << elPtr->parmelaOutputFlow() << endl;
    }

  outfile << "ZOUT" << endl;
  outfile << "START /wt=0.0 /dwt=" << globParam_.getIntegrationStep() << "  /nsteps=" << globParam_.getNbSteps() << "  nsc=" << globParam_.getScPeriod() << "  /nout=10" << endl;
  outfile << "END" << endl;
  outfile.close();
}

void dataManager::initializeExecution()
{
  removeFile("parmdesz");
  removeFile("parmin");
  removeFile("transport.input");
  removeFile("transport.output");
  //  currentBeam_.clear();
  currentBeam_ = NULL;
  clearSectionToExecute();
}

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

bool dataManager::executeAll(string &resul)
{
  bool success = true;
  resul.clear();
  string resultatPartiel;
  unsigned k;
  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) {
        success = executeParmela( debut, fin, resultatPartiel);
      } else if (jobList_[k]->software == nomDeLogiciel::transport) {
        success = executeTransport( debut, fin, resultatPartiel);
      } else {
        success = false;
        resultatPartiel =  " unknown software -- STOP \n ";     
        break;
      }
      resul += resultatPartiel;
      if ( !success ) break;
    }
  return success;
}

void dataManager::saveAll()
{
  ofstream outfile;
  string name = WORKINGAREA + "pspa.save";
  outfile.open(name.c_str(), ios::out);
  if (!outfile) {
    cerr << " error opening output file for persistency " << name << endl;
  }

  outfile << globParam_.FileOutputFlow();
  int k;
  abstractElement* elPtr;
  for ( k=0 ; k < elementsGallery_.size() ; k++)
    {
      elPtr = elementsGallery_.getElementPointer(k);
      outfile << elPtr->FileOutputFlow();
    }
  outfile.close();    
}

void dataManager::restoreElements()
{
  cout << "dataManager::restoreElements()" << endl;
      
  ifstream infile;
  string name = WORKINGAREA + "pspa.save";
  infile.open(name.c_str(), ios::in);
  if (!infile) {
    cerr << " error opening input stream " << name << endl;
  }
  
  int ielem;
  string globalTitle;
  if ( infile >> globalTitle ) {
    if ( globalTitle == string("globals") ) {
      globParam_.raz();
      globParam_.FileInput(infile);
    } else {
      cerr << " dataManager::restoreAll ERROR : global parameters seems to be missing" << endl;
    }
  } else {
    cerr << " dataManager::restoreAll ERROR : reading data save file" << endl;
  }

  elementsGallery_.raz();
  typedElement elem;
  while (infile >> ielem) {
    elem = (typedElement)ielem;
    abstractElement* nouveau = addElement(elem);
    nouveau->FileInput(infile);
  }  
  infile.close();

  // debug
  int k;
  for(k = 0; k <  elementsGallery_.size(); k++) {
    abstractElement* ptr= elementsGallery_.getElementPointer(k);
    cout << "reupere " << ptr->getLabel() << endl;
  }
}

  particleBeam* dataManager::getDiagnosticBeam(int index) 
  {
    cout << " particleBeam* dataManager je vais dessiner " << getLabelFromElementNumero(index+1) << endl;
    return &diagnosticBeam_.at(index);
  }

void dataManager::donneesRmsEnveloppe( string type, unsigned int numeroDeb, unsigned int numeroFin, vector<double>& xcor, vector<double>& ycor)
{
  unsigned k;
  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_.getElementPointer(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;
    }
}