#include "elementSoleno.h"
#include "mixedTools.h"


elementSoleno::elementSoleno() :  abstractElement() 
{
  cout << " passage constructeur elementSoleno " << endl;
  setDefaultValues();
  setDefaults();
  elementName_ = nomdElements("soleno");
  nbParam_ = elementName_.getElementNbParameters();
  parametersString_ = new string[nbParam_+1];
  // registerAcceptableSoftware(nomDeLogiciel::transport, TBoolOk);
  // registerAcceptableSoftware(nomDeLogiciel::parmela, TBoolOk);
}

void elementSoleno::setDefaultValues()
{
  defaultSpecificName_ = "solnd";
  B0Def_ = 0.0;
  varyB0Def_ = false;
}

void elementSoleno::setDefaults()
{
  specificName_ = defaultSpecificName_;
  B0_ = B0Def_;
  varyB0_ = varyB0Def_;
}

string* elementSoleno::getParametersString() const 
{
  cout << " passage elementSoleno::getParametersString() B0_= " << B0_ << endl;
  int compteur = -1;
  parametersString_[++compteur] = mixedTools::intToString(nbParam_);
  parametersString_[++compteur] = specificName_;
  parametersString_[++compteur] = mixedTools::doubleToString(lenghtElem_);
  parametersString_[++compteur] = mixedTools::doubleToString(aperture_);
  parametersString_[++compteur] = mixedTools::doubleToString(B0_);
  parametersString_[++compteur] = mixedTools::intToString(varyB0_);
  if ( compteur != nbParam_ ) {
    cerr << " elementSoleno::getParametersString() : ERROR nr pf parameters dosnt match " << endl;
    return NULL;
  }
  return parametersString_;
}

 void  elementSoleno::setParametersString(string* param)
 {
   if ( param == NULL ) {
     cerr << "  elementSoleno::setParametersString parameters empty parameter set";
     return;
   }
   int compteur = -1;
   int nbparam = atoi(param[++compteur].c_str());
   if ( nbparam != nbParam_ ) {
     cerr << "  elementSoleno::setParametersString parameters do not match for a SOLENOID";
     return;
   }
   specificName_ = param[++compteur];
   lenghtElem_ = atof(param[++compteur].c_str());
   aperture_  = atof(param[++compteur].c_str());
   B0_ = atof(param[++compteur].c_str());
   varyB0_ = atoi(param[++compteur].c_str());
 }

// string elementSoleno::parmelaOutputFlow() const
//   {
//     ostringstream sortie;
//     // on passe l'induction magnetique en Gauss 
//     sortie << "SOLENOID /l=" << lenghtElem_ << "  /aper=" << aperture_ << "  /iout=1 /h=" << 1000.*B0_  << endl;
//     return sortie.str();
//   }

// string elementSoleno::transportOutputFlow() const
//   {
//     ostringstream sortie;
//     // on passe la longueur en metres 
//     sortie << specificName_ << ":" << "  SOLENOID, L=" << 0.01*lenghtElem_ << ", B=" << B0_ << ";" << endl;
//     if ( varyB0_ ) {
//       sortie <<  "  VARY, " << specificName_+"[B]"  << ";" << endl;
//     }
//     return sortie.str();
//   }

string elementSoleno::FileOutputFlow() const
{
  ostringstream sortie;
  //    sortie << elementName_.getElementType() << endl;
  sortie << elementName_.getGenericLabel() << endl;
  sortie  << specificName_ << endl;
  sortie << lenghtElem_ << "  " << aperture_<< " "  << B0_ << " " << varyB0_ << endl;
  return sortie.str();
}


vector< pair<string, vector<string> > > elementSoleno::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> >("lenghtAperture",  vector<string>() ) );
  sortie.back().second.push_back(mixedTools::doubleToString(lenghtElem_));
  sortie.back().second.push_back(mixedTools::doubleToString(aperture_));
  sortie.push_back( pair<string, vector<string> >("field",  vector<string>() ) );
  sortie.back().second.push_back(mixedTools::doubleToString(B0_));
  sortie.push_back( pair<string, vector<string> >("isBvariable",  vector<string>() ) );
  sortie.back().second.push_back(mixedTools::intToString(varyB0_));
  return sortie;
}

void elementSoleno::FileInput(ifstream& ifs)
{
  ifs >> specificName_;
  ifs >> lenghtElem_ >>  aperture_ >> B0_ >> varyB0_ ;
}

string elementSoleno::print() 
{
  string txt = "";
  txt += specificName_;
  txt += "\nlength (cm) : ";
  txt += mixedTools::doubleToString(lenghtElem_);
  txt += "\naperture (cm) : ";
  txt += mixedTools::doubleToString(aperture_);
  txt += "\nfield (kG) : ";
  txt += mixedTools::doubleToString(B0_);
  txt += "\n : may vary ? ";
  txt += mixedTools::boolToString(varyB0_);  
  return txt;
}

void elementSoleno::InputRep(UAPNode* root)
{
  UAPNode* ele = root->addChild("element");
  ele->addAttribute("name",specificName_);

  string txt = "";
  txt = mixedTools::doubleToString(lenghtElem_);
  ele->addChild("length")->addAttribute("design",txt);

  // pour Parmela /aper : radius of aperture at exit (gap)
  UAPNode* node = ele->addChild("aperture");
  node->addAttribute("at","EXIT");
  node->addAttribute("shape","CIRCLE");
  txt = mixedTools::doubleToString(aperture_);
  node->addChild("xy_limit")->addAttribute("design",txt);

  node = ele->addChild("solenoid");
  txt = mixedTools::doubleToString(B0_);
  node->addChild("ksol")->addAttribute("design",txt);

  // faire varier ou pas l'induction pour l'ajuster
  if ( varyB0_ ) {
    node->addChild("vary")->addAttribute("is_on","true");
  } else {
    node->addChild("vary")->addAttribute("is_on","false");
  }
}