Changeset 455 in PSPA for Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_accelerator.cc

Timestamp:

Dec 16, 2013, 5:16:54 PM (10 years ago)

Author:

garnier

Message:

grosse modification pour intégrer les sections

File:

• Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_accelerator.cc (modified) (5 diffs)

Interface_Web/trunk/pspaWT/sources/userInterface/src/GWt_accelerator.cc

@@ -8 +8 @@
 #include <Wt/WHBoxLayout>
 #include <Wt/WComboBox>
+#include <Wt/WRadioButton>
 #include <Wt/WPushButton>
 #include <Wt/WGroupBox>
+#include <Wt/WStandardItemModel>
 
 #include <string>
 
-GWt_accelerator::GWt_accelerator(WContainerWidget* parent, PspaApplication* pspa) :
+GWt_accelerator::GWt_accelerator(WContainerWidget* parent, dataManager* dt) :
 WContainerWidget(parent),
-pspa_(pspa)
+dataManager_(dt)
 {
   setObjectName("accelerator");
   addStyleClass("acceleratorPanel");
-    
+  nameOfCase_ = "pspa"; // default  // FIXME
+  
+
   WContainerWidget* menu = new WContainerWidget(this);
   menu->addStyleClass("acceleratorMenu");
@@ -59 +63 @@
   runParameters->setMinimumSize(32,32);
   
+  WPushButton* boutongraphicalAnalysis = new WPushButton("",menu);
+  boutongraphicalAnalysis->setStyleClass("histoButton");
+  boutongraphicalAnalysis->setToolTip ("analyse graphique");
+  boutongraphicalAnalysis->setMaximumSize(32,32);
+  boutongraphicalAnalysis->setMinimumSize(32,32);
+
+  
   new WBreak(this);
   
@@ -79 +90 @@
   addSectorParameters->clicked().connect(this,&GWt_accelerator::addSector);
   runParameters->clicked().connect(this,&GWt_accelerator::run);
-
+  boutongraphicalAnalysis->clicked().connect(this, &GWt_accelerator::dialogOnGraphics);
+
+  graphicsDialog_ = new GWt_dialog("graphical analysis",createDrawingWidget(),false);
+  graphicsDialog_->setMinimumSize(400,400);
+  graphicsDialog_->setClosable(true);
+  graphicsDialog_->hide();
   
 }
@@ -90 +106 @@
 void GWt_accelerator::addSector()
 {
-  sector* sect = pspa_->getDataManager()->addNewSector();
+  sector* sect = getDataManager()->addNewSector();
   GWt_sector* addedSector = new GWt_sector(this,sect);
 }
@@ -97 +113 @@
 {
 }
+
+void GWt_accelerator::faireDessin()
+{
+  choixElementDessin_->clear();
+  choixHistoDessin_->clear();
+  
+  for (unsigned k = 0; k < getDataManager()->getSectors().size(); k++) {
+    sector* sector = getDataManager()->getSectors()[k];
+    for (unsigned l = 0; l < sector->getSectionsToExecute().size(); l++) {
+      sectionToExecute* section = sector->getSectionsToExecute()[l];
+      for (unsigned m = 0; m < section->getElements().size(); m++) {
+        
+        abstractElement* elPtr = section->getElements()[m];
+        //    if(elPtr->getNomdElement().getElementType() == snapshot) continue;
+        
+        choixElementDessin_->addItem(elPtr->getLabel());
+        choixHistoDessin_->addItem(elPtr->getLabel());
+      }
+    }
+  }
+}
+
+WContainerWidget* GWt_accelerator::createDrawingWidget()
+{
+  WGridLayout *glayout= new WGridLayout();
+  WContainerWidget* dessin = new WContainerWidget();
+  dessin->setLayout(glayout);
+  
+  group_ = new Wt::WButtonGroup(this);
+  
+  /////////////////////////////////////////////////////////////////////
+  
+  choixEnveloppeDessin_ = new WComboBox();
+  choixEnveloppeDessin_->addItem("x");
+  // choixEnveloppeDessin_->addItem("y");
+  Wt::WRadioButton *button1= new WRadioButton(" enveloppe");
+  group_->addButton(button1,1);
+  glayout->addWidget(button1,0,1);
+  glayout->addWidget(choixEnveloppeDessin_,0,2);
+  /////////////////////////////////////////////////////////////////////
+  
+  choixElementDessin_ = new WComboBox();
+  choixElementDessin_->setMinimumSize(50,10);
+  choixTypeDessinFaisceau_ = new WComboBox();
+  choixTypeDessinFaisceau_->addItem("courant_snyder");
+  choixTypeDessinFaisceau_->addItem("macroparticles");
+  Wt::WRadioButton *button2= new WRadioButton(" phase space after element");
+  
+  choixAbsPhase_ = new WComboBox();
+  choixAbsPhase_->addItem("x");
+  choixAbsPhase_->addItem("y");
+  choixAbsPhase_->addItem("dz");
+  choixAbsPhase_->addItem("xp");
+  choixAbsPhase_->addItem("yp");
+  choixAbsPhase_->addItem("dE/E");
+  choixAbsPhase_->setCurrentIndex(0);
+  
+  choixOrdPhase_ = new WComboBox();
+  choixOrdPhase_->addItem("x");
+  choixOrdPhase_->addItem("y");
+  choixOrdPhase_->addItem("dz");
+  choixOrdPhase_->addItem("xp");
+  choixOrdPhase_->addItem("yp");
+  choixOrdPhase_->addItem("dE/E");
+  choixOrdPhase_->setCurrentIndex(3);
+  
+  group_->addButton(button2,2);
+  glayout->addWidget(button2,1,1);
+  glayout->addWidget(choixElementDessin_,1,2);
+  glayout->addWidget(choixTypeDessinFaisceau_,1,3);
+  //  glayout->addWidget(new WText("abs. :"),2,2);
+  glayout->addWidget(choixAbsPhase_,2,2);
+  //  glayout->addWidget(new WText("ord. :"),2,4);
+  glayout->addWidget(choixOrdPhase_,2,3);
+  /////////////////////////////////////////////////////////////////////
+  
+  choixVariableHisto_= new WComboBox();
+  choixVariableHisto_->addItem("x");
+  choixVariableHisto_->addItem("y");
+  choixVariableHisto_->addItem("z");
+  choixVariableHisto_->addItem("xp");
+  choixVariableHisto_->addItem("yp");
+  choixVariableHisto_->addItem("dE/E");
+  choixVariableHisto_->setCurrentIndex(5);
+  
+  choixHistoDessin_ = new WComboBox();
+  Wt::WRadioButton *button3= new WRadioButton(" histogram after element ");
+  group_->addButton(button3,3);
+  
+  glayout->addWidget(button3,3,1);
+  glayout->addWidget(choixHistoDessin_,3,2);
+  glayout->addWidget(choixVariableHisto_,3,3);
+  /////////////////////////////////////////////////////////////////////
+  
+  WPushButton *close= new WPushButton("close");
+  glayout->addWidget(close,4,1);
+  close->clicked().connect(this,&GWt_accelerator::closeGraphicDialog);
+  
+  WPushButton *draw= new WPushButton("draw");
+  glayout->addWidget(draw,4,2,2,1);
+  draw->clicked().connect(this,&GWt_accelerator::dessiner);
+  /////////////////////////////////////////////////////////////////////
+  
+  toto_ = new WContainerWidget();
+  dessin->addWidget(toto_);
+  return dessin;
+}
+
+
+void GWt_accelerator::dialogOnGraphics()
+{
+  graphicsDialog_->show();
+}
+
+
+void GWt_accelerator::closeGraphicDialog()
+{
+  cout << " close graphicsDialog_" << endl;
+  for(unsigned i = 0; i < eDialog_.size(); i++) eDialog_[i]->done(WDialog::Rejected);
+  eDialog_.clear();
+  graphicsDialog_->done(WDialog::Rejected);
+}
+
+
+
+void GWt_accelerator::dessiner()
+{
+  int k= group_->checkedId();
+  cout << "dessiner k= " << k << endl;
+  
+  switch(k) {
+    case  1:
+      dessinerEnveloppe();
+      break;
+    case 2:
+      dessinerPhaseSpace();
+      break;
+    case 3:
+      dessinerHistogramme();
+      break;
+    default:
+      GWt_dialog graphicalWarning("graphical analysis","select a button",GWt_dialog::Warning,false,true);
+      graphicalWarning.exec();
+      break;
+  }
+}
+
+void GWt_accelerator::dessinerPhaseSpace()
+{
+  
+  int typeFaisceau = choixTypeDessinFaisceau_->currentIndex();
+  //  int index = choixElementDessin_->currentIndex();
+  string nameAbs = choixAbsPhase_->currentText().toUTF8();
+  string nameOrd = choixOrdPhase_->currentText().toUTF8();
+  if ( nameAbs == nameOrd ) {
+    GWt_dialog phaseSpaceError(" graphical analysis", "the beam coordinates must be different !", GWt_dialog::Error, false,true);
+    phaseSpaceError.exec();
+    return;
+  }
+  string elementLabel = choixElementDessin_->currentText().toUTF8();
+  particleBeam* beam = dataManager_->getDiagnosticBeam_deprecated(elementLabel);
+  //  particleBeam* beam = dtmanage_->getDiagnosticBeam(index);
+  
+  if ( beam == NULL ) {
+    GWt_dialog warningBeamState(" graphical analysis", "the beam does not exist at the end of this element !", GWt_dialog::Error, false,true);
+    warningBeamState.exec();
+    return;
+  }
+  
+  toto_->clear();
+  faireDessinPhaseSpace(toto_, beam, elementLabel, nameAbs, nameOrd, typeFaisceau);
+  
+  // if ( typeFaisceau == 0 )
+  //   {
+  //     if ( !beam->momentRepresentationOk() ) beam->buildMomentRepresentation();
+  //     faireDessinTransport(toto_, beam, nameAbs, nameOrd );
+  //   }
+  // else if ( typeFaisceau == 1 )
+  //   {
+  //     if ( beam->particleRepresentationOk() ) faireDessinParmela(toto_, beam, nameAbs, nameOrd );
+  //     else {
+  //    GWt_dialog warningBeamState(" graphical analysis", "the beam state does not allow providing a drawing with macroparticles !", GWt_dialog::Error, false,true);
+  //    warningBeamState.exec();
+  //     }
+  //   }
+  // else {
+  //   GWt_dialog warningTypeDrawing(" graphical analysis", "type of  drawing not programmed !", GWt_dialog::Error, false,true);
+  //   warningTypeDrawing.exec();
+  // }
+}
+
+void GWt_accelerator::dessinerEnveloppe()
+{
+  toto_->clear();
+  
+  int typeEnveloppe = choixEnveloppeDessin_->currentIndex();
+  if ( typeEnveloppe == 0 )
+  {
+    faireDessinEnveloppe(toto_, "x");
+  }
+  else {
+    GWt_dialog warningTypeEnveloppe(" graphical analysis", "type of enveloppe drawing not programmed !", GWt_dialog::Error, false,true);
+    warningTypeEnveloppe.exec();
+  }
+}
+
+void GWt_accelerator::faireDessinEnveloppe(WContainerWidget* toto, string type)
+{
+  
+  std::time_t result = std::time(NULL);
+  
+  GWt_dialog* envDialog = new GWt_dialog(WString("enveloppe&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(")+std::asctime(std::localtime(&result))+")",toto,false);
+  eDialog_.push_back(envDialog);
+  envDialog->setMinimumSize(400,400);
+  envDialog->setClosable(true);
+  envDialog->show();
+  
+  //  unsigned nbel = dtmanage_->getBeamLineSize();
+  vector<double> xcor;
+  vector<double> ycor;
+  string titre;
+  string legendx;
+  string legendy;
+  dataManager_->donneesRmsEnveloppe(type,xcor,ycor,titre,legendx,legendy);
+  
+  Wt::Chart::SeriesType seriesType = Wt::Chart::LineSeries;
+  Wt::Chart::FillRangeType fillRange = Wt::Chart::NoFill;
+  Wt::Chart::AxisValue location = Wt::Chart::ZeroValue;
+  bool isGridLinesEnabled = false;
+  chartPlot2vec(envDialog->contents(),xcor,ycor,seriesType,fillRange,location,isGridLinesEnabled,titre,legendx,legendy,500,300);
+}
+
+void GWt_accelerator::faireDessinPhaseSpace(WContainerWidget* toto, particleBeam* beam, string elementLabel, string namex, string namey, int typeFaisceau)
+{
+  
+  vector<double> xcor;
+  vector<double> ycor;
+  vector<string> legende;
+  string titre;
+  Wt::Chart::SeriesType seriesType;
+  
+  if ( typeFaisceau == 0 ) {
+    seriesType = Wt::Chart::LineSeries;
+    titre = "phase space rms";
+    beam->donneesDessinEllipse(xcor,ycor,legende,namex,namey);
+  } else if (  typeFaisceau == 1 ) {
+    seriesType = Wt::Chart::PointSeries;
+    titre = " phase space ";
+    beam->particlesPhaseSpaceData(xcor,ycor,legende,namex,namey);
+    // for ( int kk=0; kk < xcor.size(); kk++)
+    //   {
+    //  cout << " dess. phas. x= " << xcor.at(kk) << " x'= " << ycor.at(kk) << endl;
+    //   }
+  } else {
+    GWt_dialog warningBeamState(" graphical analysis", "the beam state does not allow providing a drawing with macroparticles !", GWt_dialog::Error, false,true);
+    warningBeamState.exec();
+    return;
+  }
+  
+  std::time_t result = std::time(NULL);
+  GWt_dialog* phaseSpaceDialog = new GWt_dialog(WString("phase space&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(")+std::asctime(std::localtime(&result))+")",toto,false);
+  eDialog_.push_back(phaseSpaceDialog);
+  phaseSpaceDialog->setMinimumSize(400,400);
+  phaseSpaceDialog->setClosable(true);
+  new WText(" case : " + nameOfCase_, phaseSpaceDialog->contents());
+  new WBreak(phaseSpaceDialog->contents());
+  new WText(" after element :  " + elementLabel, phaseSpaceDialog->contents());
+  
+  for (int k=0 ; k < (int)legende.size(); k++) {
+    new WBreak(phaseSpaceDialog->contents());
+    new WText(legende.at(k), phaseSpaceDialog->contents());
+  }
+  
+  Wt::Chart::FillRangeType fillRange = Wt::Chart::NoFill;
+  Wt::Chart::AxisValue location = Wt::Chart::ZeroValue;
+  bool isGridLinesEnabled = false;
+  chartPlot2vec(phaseSpaceDialog->contents(),xcor,ycor,seriesType,fillRange,location,isGridLinesEnabled,titre,namex,namey,500,300);
+  
+  phaseSpaceDialog->show();
+}
+
+
+void GWt_accelerator::dessinerHistogramme()
+{
+  toto_->clear();
+  
+  // std::time_t result = std::time(NULL);
+  // GWt_dialog* histoDialog = new GWt_dialog(WString("histogramme&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(")+std::asctime(std::localtime(&result))+")",toto_,false);
+  // eDialog_.push_back(histoDialog);
+  // histoDialog->setMinimumSize(400,400);
+  // histoDialog->setClosable(true);
+  
+  string elementLabel = choixHistoDessin_->currentText().toUTF8();
+  particleBeam* beam = dataManager_->getDiagnosticBeam_deprecated(elementLabel);
+  if (beam == NULL) {
+    GWt_dialog warningBeamState("histogram","the beam does not exist at the end of this element !", GWt_dialog::Error, false,true);
+    warningBeamState.exec();
+    return;
+  }
+  
+  if (!beam->particleRepresentationOk()) {
+    GWt_dialog warningBeamState("histogram", "the beam state does not allow providing a drawing with macroparticles !", GWt_dialog::Error, false,true);
+    warningBeamState.exec();
+    return;
+  }
+  
+  unsigned iabs= choixVariableHisto_->currentIndex();
+  vector<double> xcor;
+  vector<int> hist;
+  //  double out[3]= {0.0};
+  vector<string> legende;
+  beam->histogramme(iabs,xcor,hist,legende);
+  
+  cout<<"xcor.size()= "<<xcor.size()<<", hist.size()= "<<hist.size()<<endl;
+  //////////////////////////////////////////////////////////////////////////////////
+  
+  int n = hist.size();
+  vector<double> x;
+  x.resize(2*n+2);
+  vector<double> y;
+  y.resize(2*n+2);
+  
+  int j= 0;
+  x.at(j)= xcor[0];
+  y.at(j)= 0.0;
+  j++;
+  x.at(j)= xcor[0];
+  y.at(j)= hist[0];
+  j++;
+  
+  for (int i = 1; i < n; ++i) {
+    x.at(j)= xcor[i];
+    y.at(j)= hist[i-1];
+    j++;
+    x.at(j)= xcor[i];
+    y.at(j)= hist[i];
+    j++;
+  }
+  
+  x.at(j)= xcor[n];
+  y.at(j)= hist[n-1];
+  j++;
+  x.at(j)= xcor[n];
+  y.at(j)= 0.0;
+  //////////////////////////////////////////////////////////////////////////////////
+  std::time_t result = std::time(NULL);
+  GWt_dialog* histoDialog = new GWt_dialog(WString("histogramme&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(")+std::asctime(std::localtime(&result))+")",toto_,false);
+  eDialog_.push_back(histoDialog);
+  histoDialog->setMinimumSize(400,400);
+  histoDialog->setClosable(true);
+  
+  histoDialog->show();
+  
+  WContainerWidget *w= histoDialog->contents();
+  
+  // // legendes
+  // string unites[2];
+  // if(iabs == 0 || iabs == 1 || iabs == 2) {
+  //   unites[0]= unites[1]= " mm";
+  // }
+  // if(iabs == 3 || iabs == 4) {
+  //   unites[0]= unites[1]= " mrad";
+  // }
+  // if(iabs == 5) {
+  //   unites[0]= " MeV"; unites[1]= " KeV";
+  // }
+  
+  new WText(" case : " + nameOfCase_, w);
+  new WBreak(w);
+  new WText(" after element :  " + elementLabel, w);
+  
+  for (int k=0 ; k < (int)legende.size(); k++) {
+    new WBreak(w);
+    new WText(legende.at(k), w);
+  }
+  
+  
+  // new WText(" entries : "+ mixedTools::intToString((int)out[0]),w);
+  // new WBreak(w);
+  // new WText(" mean : "+ mixedTools::doubleToString(out[1])+unites[0],w);
+  // new WBreak(w);
+  // new WText(" sigma rms : "+ mixedTools::doubleToString(out[2])+unites[1],w);
+  //////////////////////////////////////////////////////////////////////////////////
+  
+  string titre;
+  if(iabs == 0) titre="x-coordinate";
+  if(iabs == 1) titre="y-coordinate";
+  if(iabs == 2) titre="z-coordinate";
+  if(iabs == 3) titre="xp-divergence";
+  if(iabs == 4) titre="yp-devergence";
+  if(iabs == 5) titre="kinetic energy";
+  
+  string xname;
+  if(iabs == 0) xname=" x (mm)";
+  if(iabs == 1) xname=" y (mm)";
+  if(iabs == 2) xname=" z (mm)";
+  if(iabs == 3) xname=" xp (mrad)";
+  if(iabs == 4) xname=" yp (mrad)";
+  if(iabs == 5) xname=" dEcin/Ecin (%)";
+  
+  string yname;
+  Wt::Chart::SeriesType seriesType = Wt::Chart::LineSeries;
+  Wt::Chart::FillRangeType fillRange = Wt::Chart::ZeroValueFill;
+  Wt::Chart::AxisValue location = Wt::Chart::MinimumValue;
+  bool isGridLinesEnabled = true;
+  chartPlot2vec(w,x,y,seriesType,fillRange,location,isGridLinesEnabled,titre,xname,yname,500,300);
+}
+
+
+
+void GWt_accelerator::chartPlot2vec(WContainerWidget* toto,vector<double>& xcor,vector<double>& ycor,Wt::Chart::SeriesType seriesType,Wt::Chart::FillRangeType fillRange,Wt::Chart::AxisValue value,bool isGridLinesEnables,string title,string legendx,string legendy,int width,int height,bool makeIcon)
+{
+  int nbpts = xcor.size();
+  cout << " PspaApplication::chartPlot2vec nbpts = " << nbpts << endl;
+  
+  WStandardItemModel *model = new WStandardItemModel(nbpts, 2, toto);
+  for (int i = 0; i < nbpts; ++i) {
+    model->setData(i, 0, xcor.at(i));
+    model->setData(i, 1, ycor.at(i));
+    //        cout << " PspaApplication::chartPlot2vec el= " << i+1 << " x= " << xcor.at(i) << " y= " << ycor.at(i) << endl;
+  }
+  //  cout << " PspaApplication::chartPlot2vec FLAG 0 " << endl;
+  Wt::Chart::WCartesianChart *chart = new Wt::Chart::WCartesianChart(toto);
+  if (!makeIcon) chart->setTitle(title);
+  chart->initLayout();
+  chart->setModel(model);        // set the model
+  chart->setXSeriesColumn(0);    // set the column that holds the X data
+  
+  chart->setType(Wt::Chart::ScatterPlot);   // set type to ScatterPlot
+  chart->setLegendEnabled(false); // enable the legend
+  
+  // Provide space for the X and Y axis and title.
+  chart->setPlotAreaPadding(80, Left);
+  chart->setPlotAreaPadding(40, Bottom);
+  chart->setPlotAreaPadding(60, Top);
+  
+  // Typically, for mathematical functions, you want the axes to cross
+  // at the 0 mark (value= ZeroValue)
+  chart->axis(Wt::Chart::XAxis).setLocation(value);
+  chart->axis(Wt::Chart::YAxis).setLocation(value);
+  
+  //  cout << " PspaApplication::chartPlot2vec FLAG 1 " << endl;
+  
+  Wt::Chart::WDataSeries s(1,seriesType);
+  s.setPen(WColor("red"));
+  s.setFillRange(fillRange);
+  chart->addSeries(s);
+  
+  Wt::Chart::WAxis& axis = chart->axis(Wt::Chart::XAxis);
+  axis.setLabelFormat("%.3f");
+  axis.setTitle(legendx);
+  
+  chart->axis(Wt::Chart::Y1Axis).setTitle(legendy);
+  
+  if(isGridLinesEnables) {
+    axis.setGridLinesEnabled(true);
+    chart->axis(Wt::Chart::Y1Axis).setGridLinesEnabled(true);
+  }
+  //   cout << " PspaApplication::chartPlot2vec FLAG 2 " << endl;
+  
+  chart->resize(width,height); // WPaintedWidget must be given explicit size
+  chart->setMargin(10, Top | Bottom); // ?
+  chart->setMargin(WLength::Auto, Left | Right); //?
+  
+  if (makeIcon) {
+    chart->setLegendEnabled(false); // enable the legend
+    chart->setPlotAreaPadding(0);
+    chart->setAxisPadding(0);
+    WFont xAxisFont = chart->axis(Wt::Chart::XAxis).labelFont();
+    xAxisFont.setSize(8);
+    WFont yAxisFont = chart->axis(Wt::Chart::YAxis).labelFont();
+    yAxisFont.setSize(8);
+    chart->axis(Wt::Chart::XAxis).setLabelFont(xAxisFont);
+    chart->axis(Wt::Chart::YAxis).setLabelFont(yAxisFont);
+  }
+  //  cout << " PspaApplication::chartPlot2vec FLAG 3 " << endl;
+  
+#ifdef HAS_IMAGEMAGIC
+  
+  //  cout << " PspaApplication::chartPlot2vec FLAG MAGIC " << endl;
+  
+  // no background
+  chart->setBackground(WBrush(Wt::NoBrush));
+  
+  // axis black
+  chart->axis(XAxis).setPen(WColor("black"));
+  chart->axis(YAxis).setPen(WColor("black"));
+  
+  std::string name;
+  /*
+   Wt::WRasterImage pngImage("png", 1000, 1000);
+   Wt::WPainter p(&pngImage);
+   chart->paint(p);
+   name = workingDir_ + "/chart-"+sessionId ()+".png";
+   std::ofstream f(name.c_str(), std::ios::out |std::ios::trunc | std::ios::binary);
+   pngImage.write(f);
+   */
+  
+  Wt::WPdfImage pdfImage("1000", "600");
+  {
+    Wt::WPainter p1(&pdfImage);
+    chart->paint(p1);
+  }
+  
+  name = workingDir_ + "/chart-"+sessionId ()+".pdf";
+  std::ofstream f1(name.c_str(), std::ios::out | std::ios::binary);
+  pdfImage.write(f1);
+  
+  new WText("<a href='workingArea/chart-"+sessionId ()+".pdf' target='_blank'>Sauvegarder l'image</a>",toto);
+  
+#endif
+  //  cout << " PspaApplication::chartPlot2vec FLAG FIN" << endl;
+  
+}
+
+
+
+