source: PSPA/Interface_Web/trunk/pspaWT/sources/controler/src/softwareParmela.cc @ 314

#include "softwareParmela.h"
#include "abstractElement.h"
#include "parmelaParticle.h"
#include "mathematicalConstants.h"
#include "PhysicalConstants.h"
#include "dataManager.h"


softwareParmela::softwareParmela() : abstractSoftware()
{
  ;
}

softwareParmela::softwareParmela(globalParameters* globals, dataManager* dt) : abstractSoftware(globals, dt)
{
  ;
}

bool softwareParmela::createInputFile(string inputFileName, particleBeam* beamBefore, unsigned int numeroDeb, unsigned int numeroFin, string workingDir)
{
  unsigned int k;

  if ( numeroDeb < 1 || numeroFin > dataManager_->getBeamLineSize() ) {
    dataManager_->consoleMessage(" softwareParmela::createInputFile : numero of element out of limits " );
    cerr << " numero of element out of limits " << endl;
    return false;
  }


  ofstream outfile;
  string name = workingDir + inputFileName;
  outfile.open(name.c_str(), ios::out);
  if (!outfile) {
    dataManager_->consoleMessage(" softwareParmela::createInputFile : error opening output stream " );
    cerr << " softwareParmela::createInputFile : error opening output stream " << name << endl;
    return false;
  }

  abstractElement* elPtr;
  double initalKineticEnergy = 0.0;
  elPtr = dataManager_->getElementPointerFromNumero(numeroDeb);
  bool there_is_rfgun = ( elPtr->getNomdElement().getElementType() == RFgun ); 
  if ( !there_is_rfgun ) {
    if ( !beamToParmela(workingDir, beamBefore ) ) return false;
    initalKineticEnergy = beamBefore->referenceKineticEnergyMeV();
  }
  else {
    elPtr->setPhaseStep( globParamPtr_->getIntegrationStep() );
    initalKineticEnergy = elPtr->getInitialKineticEnergy();
  }


  outfile << "TITLE" << endl;
  outfile << " titre provisoire " << endl;
  outfile << "RUN /n0=1 /ip=999 /freq=" << globParamPtr_->getFrequency() << "  /z0=0.0 /W0=" << initalKineticEnergy << "  /itype=1" << endl;
  outfile << "OUTPUT 0" << endl;
  unsigned int premier = numeroDeb ;
  if ( there_is_rfgun ) {
      outfile << dataManager_->getElementPointerFromNumero(numeroDeb)->parmelaOutputFlow() << endl;
      premier++;
  } else {
    outfile << "INPUT 0 /NP=" << beamBefore->getNbParticles() << endl;
  }
  for ( k = premier; k <= numeroFin; k++)
    {
      elPtr = dataManager_->getElementPointerFromNumero(k);
      outfile << elPtr->parmelaOutputFlow() << endl;
    }

  outfile << "ZOUT" << endl;
  outfile << "START /wt=0.0 /dwt=" << globParamPtr_->getIntegrationStep() << "  /nsteps=" << globParamPtr_->getNbSteps() << "  nsc=" << globParamPtr_->getScPeriod() << "  /nout=10" << endl;
  outfile << "END" << endl;
  outfile.close();
  dataManager_->consoleMessage("fichier input termine pour PARMELA");
  return true;
}


bool  softwareParmela::execute(string inputFileName,unsigned int numeroDeb,unsigned int numeroFin,string workingDir)
{
  ostringstream sortie;
  bool ExecuteStatus = true;
  //  resul.clear();
  sortie << " EXECUTION DE PARMELA DE l'ELEMENT " << numeroDeb << " A L'ELEMENT " << numeroFin << endl;

  char buf[132];
  string parmelaJob = workingDir + "parmela";
  parmelaJob += string("   ");
  parmelaJob += workingDir;
  //  cout << " job parmela= " << parmelaJob << endl;

  string resultOfRun;
  bool success = launchJob(parmelaJob, resultOfRun);
  sortie << resultOfRun << endl;
  if ( !success) {
    sortie << " launching of parmela failed " << endl;
    ExecuteStatus = false;
  }
  else {
    sortie << " successful launching of parmela " << endl;
    cout << " execution parmela MARCHE " << endl;
    string::size_type nn = (resultOfRun).find("normal");
    if ( nn == string::npos ) 
      {
        sortie << " abnormal exit of parmela " << endl;
        ExecuteStatus = false;
      }
  }

  //  resul =  sortie.str();
    dataManager_->consoleMessage(sortie.str());
  
  return ExecuteStatus;
}


bool  softwareParmela::buildBeamAfterElements(unsigned int numeroDeb,unsigned int numeroFin, vector<particleBeam>& beams, string workingDir) {
  bool result = true;
        unsigned k;
        for ( k= numeroDeb; k <= numeroFin; k++)
          {
            beams.push_back(particleBeam());
            vector<double> centroid;
            bareParticle refPart;
            vector<bareParticle> particles;
            if (!beamFromParmela(workingDir,k, globParamPtr_->getFrequency(), centroid, refPart,particles ))
              {
                abstractElement* elem = dataManager_->getElementPointerFromNumero(k);
                if ( elem->is_accepted_by_software(nomDeLogiciel::parmela) == warning) {
                  int avantDernier = beams.size() -2;
                  beams.back() = beams.at(avantDernier);
                } else {
                  // sortie << " reading parmdesz  failed " << endl;
    dataManager_->consoleMessage(" softwareParmela::buildBeamAfterElements : reading parmdesz  failed " );
                  result = false;
                  break;
                }
              }
            else {
              beams.back().setWithParticles(centroid, refPart,particles); 
            }
          }
        return result;
}




bool softwareParmela::beamFromParmela(string workingDir,unsigned numeroElement, double referencefrequency, vector<double>& centroid, bareParticle& refPart,vector<bareParticle>& particles ) {
  unsigned  k;
  FILE* filefais;
  string nomfilefais = workingDir + "parmdesz";
  cout << " nom fichier desz : " << nomfilefais << endl;
  filefais = fopen(nomfilefais.c_str(), "r");

  if ( filefais == (FILE*)0 ) {
    dataManager_->consoleMessage(" beamFromParmela() erreur a l'ouverture du fichier 'parmdesz'");
    cerr << " beamFromParmela() erreur a l'ouverture du fichier" << nomfilefais  << endl;; 
    return false;
  }
  else cout << " beamFromParmela() : ouverture du fichier " << nomfilefais << endl; 

  parmelaParticle partic;
  std::vector<parmelaParticle> faisceau;

  cout << " beamFromParmela : numeroElement = " << numeroElement << endl;
  unsigned indexElement = numeroElement-1;
 



  int testNombrePartRef =0;
  double phaseRef = 0.0;

  while( partic.readFromParmelaFile(filefais) > 0 ) {
    if ( partic.ne == (int)indexElement )
      {
        faisceau.push_back(partic);

        if ( partic.np == 1 ) {
          // en principe on est sur la particule de reference
          if ( fabs(partic.xx) > EPSILON || fabs(partic.yy) > EPSILON || fabs(partic.xxp) > EPSILON  || fabs(partic.yyp) > EPSILON) {
            printf(" ATTENTION part. reference douteuse  \n");
            partic.imprim();
          }
          phaseRef = partic.phi;
          TRIDVECTOR  posRef(partic.xx,partic.yy,0.0);
          TRIDVECTOR betagammaRef(partic.xxp*partic.begamz, partic.yyp*partic.begamz, partic.begamz);
          refPart = bareParticle(posRef, betagammaRef);
          testNombrePartRef++;
          if ( testNombrePartRef != 1 ) {
            cerr << " nombre de part. de ref different de 1 : " << testNombrePartRef << " !! " << endl;
            return false;
          }
        }
      }
  }

  if ( faisceau.size() == 0) 
    {
      cerr << " beamFromParmela echec lecture  element " << numeroElement << endl;
      return false;
    }
  
  // facteur  c/ 360. pour calculer (c dphi) / (360.freq) 
  // avec freq en Mhz et dphi en degres et résultat en cm: 
  double FACTEUR =  83.3333;  // ameliorer la precision



  // pour l'instant on choisit un centroid nul;
  centroid.clear();
  centroid = vector<double>(6,0.0);

  particles.clear();
  particles.resize(faisceau.size(), bareParticle());
  double x,xp,y,yp;
  double betagammaz;
  double betaz;
  double deltaz;
  double dephas;
  double g;
  TRIDVECTOR  pos;
  TRIDVECTOR betagamma;
  // contrairement a ce qu'indique la notice PARMELA, dans parmdesz, les xp et yp 
  // sont donnes en radians
  for ( k=0; k < faisceau.size(); k++) {
    x=faisceau.at(k).xx;
    xp=faisceau.at(k).xxp;
    y=faisceau.at(k).yy;
    yp=faisceau.at(k).yyp;

    // dephasage par rapport a la reference  
    dephas = faisceau.at(k).phi - phaseRef; // degrés
    g = faisceau.at(k).wz/ERESTMeV;
    betagammaz = faisceau.at(k).begamz;
    betaz = betagammaz/(g+1.0);
    deltaz = FACTEUR * betaz * dephas / referencefrequency;
    x += xp * deltaz;
    y += yp * deltaz;
    pos.setComponents(x,y,deltaz);
    betagamma.setComponents(xp*betagammaz, yp*betagammaz, betagammaz);
    particles.at(k) = bareParticle(pos,betagamma);
  }
  return true;
}


// sauvegarde d'un 'particleBeam' sur un fichier parmela, en guise d'INPUT
// pour l'instant de nom standard 'parin.input0'
bool softwareParmela::beamToParmela(string workingDir, particleBeam* beam ) {
  if ( !beam->particleRepresentationOk() ) {
    dataManager_->consoleMessage("softwareParmela::beamToParmela : beam not in particles form : not yet programmed");
    cout << " softwareParmela::beamToParmela : beam not in particles form : not yet programmed " << endl;
    return false;
  }
  ofstream outfile;
  string name = workingDir + "parin.input0";
  outfile.open(name.c_str(), ios::out);
  if (!outfile) {
    dataManager_->consoleMessage(" softwareParmela::beamToParmela : error opening output stream ");
    cerr << " softwareParmela::beamToParmela : error opening output stream " << name << endl;
    return false;
  }

  const vector<bareParticle>& partic = beam->getParticleVector();
  unsigned k;
  double weight = 1.0;
  for ( k=0; k < partic.size(); k++) {
    outfile << partic.at(k).getPosition().output_flow() << partic.at(k).getBetaGamma().output_flow()<< weight << endl;
  }
    return true;
}