#include "elementRfgun.h"

#include "mathematicalTools.h"
#include "PhysicalConstants.h"
#include "mixedTools.h"


elementRfgun::elementRfgun() : abstractElement() 
{
  setDefaultValues();
  setDefaults();
  elementName_ = nomdElements("rfgun");
  nbParam_ = elementName_.getElementNbParameters();
  parametersString_ = new string[nbParam_+1];
  //      parmelaOk_ = true;
  // registerAcceptableSoftware(nomDeLogiciel::parmela, TBoolOk);
  // registerAcceptableSoftware(nomDeLogiciel::generator, TBoolOk);
}

void elementRfgun::setDefaultValues()
{
  defaultSpecificName_ = "rfgun";
  defaultPhaseStep_ = 1.0;
  defaultNmacrop_ = 0;
  defaultSigma_t_ = 0.0;
  defaultSigma_r_ = 0.0;
  defaultEmit_x_ = 0.0; 
  defaultEmit_y_ = 0.0; 
  defaultE_cin_ = 0.0;
  defaultSigma_E_ = 0.0;
  //    defaultNb_true_particles_ = 1.0;
  defaultTotalCharge_ = 0.0;
}

void elementRfgun::setDefaults()
{
  specificName_ = defaultSpecificName_;
  phaseStep_ = defaultPhaseStep_;
  nmacrop_ = defaultNmacrop_;
  sigma_t_ = defaultSigma_t_;
  sigma_r_ = defaultSigma_r_ ;
  emit_x_ = defaultEmit_x_;
  emit_y_ = defaultEmit_y_;
  E_cin_ = defaultE_cin_;
  sigma_E_ = defaultSigma_E_;
  //    nb_true_particles_ = defaultNb_true_particles_ ;
  totalCharge_ = defaultTotalCharge_;
}

string* elementRfgun::getParametersString() const
{
  int compteur = -1;
  parametersString_[++compteur] = mixedTools::intToString(nbParam_);
  parametersString_[++compteur] = specificName_;
  parametersString_[++compteur] = mixedTools::intToString(nmacrop_);
  parametersString_[++compteur] = mixedTools::doubleToString(sigma_t_);
  parametersString_[++compteur] = mixedTools::doubleToString(sigma_r_);
  parametersString_[++compteur] = mixedTools::doubleToString(emit_x_);
  parametersString_[++compteur] = mixedTools::doubleToString(emit_y_);
  parametersString_[++compteur] = mixedTools::doubleToString(E_cin_);
  parametersString_[++compteur] = mixedTools::doubleToString(sigma_E_);
  parametersString_[++compteur] = mixedTools::doubleToString(totalCharge_);
  return parametersString_;
}

void elementRfgun::setParametersString(string* param)
{
  if ( param == NULL ) {
    cerr << "  elementRfgun::setParametersString parameters empty parameter set";
    return;
  }
  int compteur = -1;
  int nbparam = atoi(param[++compteur].c_str());
  if ( nbparam != nbParam_ ) {
    cerr << "  elementRfgun::setParametersString parameters do not match for a DRIFT";
    return;
  }
  
  specificName_ = param[++compteur];
  nmacrop_ = atoi(param[++compteur].c_str());
  sigma_t_ = atof(param[++compteur].c_str());
  sigma_r_ = atof(param[++compteur].c_str());
  emit_x_ = atof(param[++compteur].c_str());
  emit_y_ = atof(param[++compteur].c_str());
  E_cin_ = atof(param[++compteur].c_str());
  sigma_E_ = atof(param[++compteur].c_str());
  totalCharge_ = atof(param[++compteur].c_str());  
}

// string elementRfgun::parmelaOutputFlow() const
//   {
//     ostringstream sortie;
//     // on prend les troncatures tmax et rmax à 3 sigmas 
//     sortie << "INPUT 10 /np=" << nmacrop_ << "  /sigt=" << sigma_t_ << endl;
//     sortie << "  /tmax=" << 3.3*sigma_t_ << " /sigr=" << sigma_r_ << endl;
//     sortie << " /rmax=" << 3.0*sigma_r_ << " /W0=" << E_cin_ << " /dw0=" << sigma_E_ << endl;
//     sortie << " /dwt=" << phaseStep_ << " /ran=2" << endl;

//     // on doit entrer le nb vrai de part. (avec signe moins)
    

//     sortie << "SCHEFF /beami=" << -fabs(totalCharge_)/ELECTRONANOCOULOMB << " /nprog=2 /point=-1.7"  << endl;
 
//     return sortie.str();
//   }

// string elementRfgun::generatorOutputFlow() const {
//     ostringstream sortie;
//     sortie << "Ipart=" << nmacrop_ << endl;

//     sortie << "Probe=.True." << endl;
//     sortie << "Noise_reduc=.T" << endl;
//     sortie << "Cathode=.T." << endl;
//     sortie << "Q_total=" << totalCharge_ << endl;
//     sortie << "Ref_zpos=0.0" << endl;
//     sortie << "Ref_clock=0.0" << endl;
//     sortie << "Ref_Ekin=" << E_cin_ << endl; // tjs en MeV
//     sortie << "Dist_z='g'" << endl;
//     sortie << "sig_clock=" << 1.0e-3*sigma_t_ << endl; // passage de ps en ns
//     sortie <<  "Dist_pz='g', sig_Ekin=" << 1000.*sigma_E_ << ",  emit_z=0.0 ,    cor_Ekin=0.0 " << endl;  // passage en keV
//     sortie << "Dist_x='gauss',  sig_x=" <<  10.*sigma_r_ << endl;    // passage en mm
//     sortie << "Dist_px='g', Nemit_x=" << emit_x_ << ",   cor_px=0.0" << endl;
//     sortie << "Dist_y='gauss',  sig_y=" <<  10.*sigma_r_ << endl;    // passage en mm
//     sortie << "Dist_py='g', Nemit_y=" << emit_y_ << ",   cor_py=0.0" << endl;
//     return sortie.str();
// }

string elementRfgun::FileOutputFlow() const
{
  ostringstream sortie;
  // on prend les troncatures tmax et rmax à 3 sigmas 
  //    sortie << elementName_.getElementType() << endl;
  sortie << elementName_.getGenericLabel() << endl;
  sortie  << specificName_ << endl;
  sortie <<  nmacrop_ << "  " << sigma_t_ << "  " << sigma_r_ << endl;
  sortie << emit_x_ << "  " << emit_y_ << endl; 
  sortie << E_cin_ << " " << sigma_E_ << endl;
  sortie << phaseStep_ << "  "  << totalCharge_ << endl; 
  return sortie.str();
}

vector< pair<string, vector<string> > > elementRfgun::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> >("nbMacroparticles",  vector<string>() ) );
  sortie.back().second.push_back(mixedTools::intToString(nmacrop_));
  sortie.push_back( pair<string, vector<string> >("sigmasTR",  vector<string>() ) );
  sortie.back().second.push_back(mixedTools::doubleToString(sigma_t_));
  sortie.back().second.push_back(mixedTools::doubleToString(sigma_r_));
  sortie.push_back( pair<string, vector<string> >("emittancesXY",  vector<string>() ) );
  sortie.back().second.push_back(mixedTools::doubleToString(emit_x_));
  sortie.back().second.push_back(mixedTools::doubleToString(emit_y_));
  sortie.push_back( pair<string, vector<string> >("kineticE",  vector<string>() ) );
  sortie.back().second.push_back(mixedTools::doubleToString(E_cin_));
  sortie.back().second.push_back(mixedTools::doubleToString(sigma_E_));
  sortie.push_back( pair<string, vector<string> >("phaseStep",  vector<string>() ) );
  sortie.back().second.push_back(mixedTools::doubleToString(phaseStep_));
  sortie.push_back( pair<string, vector<string> >("totalCharge",  vector<string>() ) );
  sortie.back().second.push_back(mixedTools::doubleToString(totalCharge_));
  return sortie;
}

void elementRfgun::FileInput(ifstream& ifs)
{
  ifs >> specificName_;
  ifs >> nmacrop_ >> sigma_t_ >> sigma_r_;
  ifs >> emit_x_  >>  emit_y_; 
  ifs >> E_cin_ >> sigma_E_;
  ifs >> phaseStep_ >> totalCharge_;
}

string elementRfgun::print() 
{
  string txt = "";
  txt += specificName_;
  txt += "\ntotal charge : ";
  txt += mixedTools::doubleToString(totalCharge_);
  txt += "\nsigma_t (ps) : ";
  txt += mixedTools::doubleToString(sigma_t_);
  txt += "\nsigma_r (cm) : ";
  txt += mixedTools::doubleToString(sigma_r_);
  txt += "\nemittance x (pi.mm.mrad) : ";
  txt += mixedTools::doubleToString(emit_x_);
  txt += "\nemittance y (pi.mm.mrad) : ";
  txt += mixedTools::doubleToString(emit_y_);
  txt += "\ninitial kinetic energy (MeV) : ";
  txt += mixedTools::doubleToString(E_cin_);
  txt += "\nsigma_Ecin (MeV) : ";
  txt += mixedTools::doubleToString(sigma_E_);
  txt += "\ntrue number of part. in beam : ";
  txt += mixedTools::boolToString(nmacrop_);
  return txt;
}

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

  UAPNode* node = ele->addChild("comment");
  node->addAttribute("type","RFgun");
  node->addAttribute("text","to simulate emission from a photocathode");

  node = ele->addChild("beam");
  node->addChild("particle")->addAttribute("type","ELECTRON");
  string txt = "";
  txt = mixedTools::intToString(nmacrop_);
  node->addChild("n_particles")->addAttribute("design",txt);
  txt = mixedTools::doubleToString(sigma_t_);
  node->addChild("sig_t")->addAttribute("design",txt);
  txt = mixedTools::doubleToString(emit_x_);
  node->addChild("emittance_a")->addAttribute("design",txt);
  txt = mixedTools::doubleToString(emit_y_);
  node->addChild("emittance_b")->addAttribute("design",txt);
  txt = mixedTools::doubleToString(E_cin_);
  txt = mixedTools::doubleToString(E_cin_);
  node->addChild("total_energy")->addAttribute("design",txt);
  txt = mixedTools::doubleToString(sigma_E_);
  node->addChild("sig_e")->addAttribute("design",txt);
  txt = mixedTools::doubleToString(totalCharge_);
  node->addChild("particle_charge")->addAttribute("design",txt);

  // gaussian radial profile
  txt = mixedTools::doubleToString(sigma_r_);
  ele->addChild("sigma_r")->addAttribute("value",txt);
  // integration step size (specific to Parmela)
  txt = mixedTools::doubleToString(phaseStep_);
  ele->addChild("phaseStep")->addAttribute("value",txt);
}