#include "elementBeam.h"
#include "beam2Moments.h"
#include "mixedTools.h"

elementBeam::elementBeam() :  abstractElement() 
{
  setDefaultValues();
  setDefaults();
  elementName_ = nomdElements("beam");
  nbParam_ = elementName_.getElementNbParameters();
  parametersString_ = new string[nbParam_+1];
  // transportOk_ = true;
  // registerAcceptableSoftware(nomDeLogiciel::transport, TBoolOk);
}

elementBeam::~elementBeam() {;}

void elementBeam::setDefaultValues() 
{
  defaultSpecificName_ = "beam";
  xDef_ = 0.0;
  xpDef_ = 0.0;
  yDef_ = 0.0;
  ypDef_ = 0.0;
  dlDef_ = 0.0;
  delDef_ = 0.0;
  p0Def_ = 0.0;
}

void elementBeam::setDefaults() 
{
  specificName_ = defaultSpecificName_;
  x_ = xDef_;
  xp_ = xpDef_;
  y_ = yDef_;
  yp_ = ypDef_;
  dl_ = dlDef_;
  del_ = delDef_;
  p0_ = p0Def_;
}

string* elementBeam::getParametersString() const 
{
  int compteur = -1;
  parametersString_[++compteur] = mixedTools::intToString(nbParam_);
  parametersString_[++compteur] = specificName_;
  parametersString_[++compteur] = mixedTools::doubleToString(x_);
  parametersString_[++compteur] = mixedTools::doubleToString(xp_);
  parametersString_[++compteur] = mixedTools::doubleToString(y_);
  parametersString_[++compteur] = mixedTools::doubleToString(yp_);
  parametersString_[++compteur] = mixedTools::doubleToString(dl_);
  parametersString_[++compteur] = mixedTools::doubleToString(del_);
  parametersString_[++compteur] = mixedTools::doubleToString(p0_);
  if ( compteur != nbParam_ ) {
    cerr << " elementBeam::getParametersString() : ERROR nr pf parameters doesnt match " << endl;
    return NULL;
  }
  return parametersString_;
}

void elementBeam::setParametersString(string* param)
{
  if ( param == NULL ) {
    cerr << "  elementBeam::setParametersString parameters empty parameter set";
    return;
  }
  int compteur = -1;
  int nbparam = atoi(param[++compteur].c_str());
  if ( nbparam != nbParam_ ) {
    cerr << "  elementBeam::setParametersString parameters do not match for a BEAM";
    return;
  }
    
  specificName_ = param[++compteur];
  x_ = atof(param[++compteur].c_str());
  xp_ = atof(param[++compteur].c_str());
  y_ = atof(param[++compteur].c_str());
  yp_ = atof(param[++compteur].c_str());
  dl_ = atof(param[++compteur].c_str());
  del_ = atof(param[++compteur].c_str());
  p0_ = atof(param[++compteur].c_str());
}

// string elementBeam::parmelaOutputFlow() const
// {
//     ostringstream sortie;
//     cout << " BEAM sortie parmela non programmee " << endl;
//     return sortie.str();
// }

// string elementBeam::transportOutputFlow() const {
//     ostringstream sortie;
//     beam2Moments moments(x_, xp_, y_, yp_, dl_, del_);
//     cout << " elementBeam::transportOutputFlow(), p0 = " << p0_ << endl;
//     sortie << specificName_ << ":" << moments.writeToTransportInput(p0_) << endl;
//     return sortie.str();
// }

// string elementBeam::FileOutputFlow() const 
// {
//   ostringstream sortie;
//   // sortie << elementName_.getElementType() << endl;
//   sortie << elementName_.getGenericLabel() << endl;
//   sortie  << specificName_ << endl;
//   sortie << x_ << "  " << xp_ << " " <<  y_  << " " <<  yp_  << endl;
//   sortie << dl_ << "  " << del_ << " " <<  p0_  << endl;
//   cout << " elementBeam::FileOutputFlow, p0 = " << p0_ << endl;
//   return sortie.str();
// }

vector< pair<string, vector<string> > > elementBeam::parametersToSoftware () const 
{
  vector< pair<string, vector<string> > >  sortie;
  sortie.push_back( pair<string, vector<string> >("labelsGenericSpecific",  vector<string>() ) );
  sortie.back().second.push_back(elementName_.getGenericLabel());
  sortie.back().second.push_back(specificName_);
  sortie.push_back( pair<string, vector<string> >("transverseCoordinates",  vector<string>() ) );
  sortie.back().second.push_back(mixedTools::doubleToString(x_));
  sortie.back().second.push_back(mixedTools::doubleToString(xp_));
  sortie.back().second.push_back(mixedTools::doubleToString(y_));
  sortie.back().second.push_back(mixedTools::doubleToString(xp_));
  sortie.push_back( pair<string, vector<string> >("longitudinalCoordinates",  vector<string>() ) );
  sortie.back().second.push_back(mixedTools::doubleToString(dl_));
  sortie.back().second.push_back(mixedTools::doubleToString(del_));		    
  sortie.push_back( pair<string, vector<string> >("momentum",  vector<string>() ) );
  sortie.back().second.push_back(mixedTools::doubleToString(p0_));
  return sortie;
}

// void elementBeam::FileInput(ifstream& ifs) 
// {
//   ifs >> specificName_;
//   ifs >> x_ >> xp_ >>  y_ >> yp_;
//   ifs >> dl_ >> del_ >> p0_;
//   cout << " elementBeam::FileFileInput, p0 = " << p0_ << endl;
//   lenghtElem_ = getLenghtOfElement();
//   cout << " elementBeam::FileInput calcule longueur = " << lenghtElem_ << endl;
// }

void elementBeam::FileAMLInput(UAPNode* entree) 
{
  // if ( !entree ) return;
  // string nonGenerique;
  // AMLtools::readAMLParameterAttribut(*iter, "description", "type", nonGenerique);
  // if ( nonGenerique != elementName_.getGenericLabel() ) {
  //   cout << " elementBeam::FileAMLInput ERREUR d'element : " << nonGenerique << " ? attendu : " <<  elementName_.getGenericLabel() << endl;
  //   return;
  // }

  if ( !checkAMLelementGenericName(entree) ) return;
  UAPNode* faisceau = entree->getChildByName("beam");
  if ( !faisceau ) {
    cout << " elementBeam::FileAMLInput ERREUR pas de noeud AML <beam> : " << endl;
    return;
  }
  AMLtools::readAMLParameterAttribut(faisceau, "11", "design", x_);
  AMLtools::readAMLParameterAttribut(faisceau, "22", "design", xp_);
  AMLtools::readAMLParameterAttribut(faisceau, "33", "design", y_);
  AMLtools::readAMLParameterAttribut(faisceau, "44", "design", yp_);
  AMLtools::readAMLParameterAttribut(faisceau, "55", "design", dl_);
  AMLtools::readAMLParameterAttribut(faisceau, "66", "design", del_);
  AMLtools::readAMLParameterAttribut(faisceau, "pc", "design", p0_);
  lenghtElem_ = getLenghtOfElement();
  cout << " elementBeam::FileAMLInput calcule longueur = " << lenghtElem_ << endl;
}



string elementBeam::print() 
{
  string txt = "";
  txt += specificName_;
  txt += "\n 1/2 horizontal beam extend rms (cm) : ";
  txt += mixedTools::doubleToString(x_);
  txt += "\n 1/2 horizontal beam divergence rms (mrad) : ";
  txt += mixedTools::doubleToString(xp_);
  txt += "\n1/2 vertical beam extend rms (cm) : ";
  txt += mixedTools::doubleToString(y_);
  txt += "\n1/2 horizontal beam divergence rms (mrad) : ";
  txt += mixedTools::doubleToString(yp_);
  txt += "\n1/2 longitudinal beam extend rms (cm) : ";
  txt += mixedTools::doubleToString(dl_);
  txt += "\n1/2 momentum spread rms (mrad) : ";
  txt += mixedTools::doubleToString(del_);
  txt += "\nmomentum of the central trajectory (GeV/c) : ";
  txt += mixedTools::doubleToString(p0_);  
  return txt;
}

void elementBeam::InputRep(UAPNode* root)
{
  // UAPNode* ele = root->addChild("element");
  // ele->addAttribute("name",specificName_);
  UAPNode* ele = setAMLelementHeader(root);
  
  UAPNode* node = ele->addChild("beam");

  // je fixe le type de particule, plus tard on pourra donner le choix
  node->addChild("particle")->addAttribute("type","ELECTRON");

  // matrice 6X6
  UAPNode* snode = node->addChild("sigma_matrix");
  string txt = "";
  txt = mixedTools::doubleToString(x_);
  snode->addChild("11")->addAttribute("design",txt);
  txt = mixedTools::doubleToString(xp_);
  snode->addChild("22")->addAttribute("design",txt);
  txt = mixedTools::doubleToString(y_);
  snode->addChild("33")->addAttribute("design",txt);
  txt = mixedTools::doubleToString(yp_);
  snode->addChild("44")->addAttribute("design",txt);
  txt = mixedTools::doubleToString(dl_);
  snode->addChild("55")->addAttribute("design",txt);
  txt = mixedTools::doubleToString(del_);
  snode->addChild("66")->addAttribute("design",txt);

  // momentum of the central trajectory (GeV/c)
  txt = mixedTools::doubleToString(p0_);
  node->addChild("pc")->addAttribute("design",txt);
}