Changeset 482 in PSPA

Timestamp:

Jan 21, 2014, 1:52:16 PM (10 years ago)

Author:

touze

Message:

maj dans le fichier d'appel de madx

Location:

Interface_Web/trunk/pspaWT/sources/controler

Files:

• include/beam2Moments.h (modified) (1 diff)
• include/sectionToExecute.h (modified) (1 diff)
• include/softwareMadx.h (modified) (2 diffs)
• src/beam2Moments.cc (modified) (1 diff)
• src/dataManager.cc (modified) (4 diffs)
• src/particleBeam.cc (modified) (1 diff)
• src/softwareMadx.cc (modified) (6 diffs)

Interface_Web/trunk/pspaWT/sources/controler/include/beam2Moments.h

@@ -19 +19 @@
 
  public :
-
+  
   beam2Moments();
-
-~beam2Moments();
+  
+  ~beam2Moments();
 
 
-beam2Moments( beam2Moments& tm);
+  beam2Moments( beam2Moments& tm);
 
-beam2Moments(const beam2Moments& tm);
+  beam2Moments(const beam2Moments& tm);
 
- beam2Moments(double x, double xp, double y, double yp, double dl, double del);
+  beam2Moments(double x, double xp, double y, double yp, double dl, double del);
 
-// const vector< vector<double> >& getMoments() const;
- vector< vector<double> >& getMatrix();
- void raz();
+  // const vector< vector<double> >& getMoments() const;
+  vector< vector<double> >& getMatrix();
+  const vector< vector<double> >& getMoments() const;
 
- // void readFromTransportOutput(ifstream& inp);
- bool readFromTransportOutput(stringstream& inp);
- string writeToTransportInput(double P0) const;
+  void raz();
 
- void impression() const;
+  // void readFromTransportOutput(ifstream& inp);
+  bool readFromTransportOutput(stringstream& inp);
+  string writeToTransportInput(double P0) const;
+
+  void impression() const;
 
   // operators

Interface_Web/trunk/pspaWT/sources/controler/include/sectionToExecute.h

@@ -39 +39 @@
   inline std::vector< abstractElement* > getElements() {return elements_;};
   
+  inline sector* getSector() const {return sector_;};
+
   /**
    Get the last element of this section

Interface_Web/trunk/pspaWT/sources/controler/include/softwareMadx.h

@@ -8 +8 @@
 class softwareMadx : public abstractSoftware
 {
+  string BEAMcommand(particleBeam*) const;
+  string RFGunData(const vector<statements>&) const; 
   string inputFormat(const vector<statements>&) const;
 
@@ -13 +15 @@
   
   softwareMadx();
-  softwareMadx(string,sectionToExecute*, dataManager*);
+  softwareMadx(string,sectionToExecute*,dataManager*);
   virtual ~softwareMadx() {;}
 
-  virtual bool createInputFile(particleBeam*, string);
+  virtual bool createInputFile(particleBeam*,string);
   virtual bool execute(string);
   virtual bool buildBeamAfterElements(string);

Interface_Web/trunk/pspaWT/sources/controler/src/beam2Moments.cc

@@ -49 +49 @@
 }
 
+const vector< vector<double> >& beam2Moments::getMoments() const 
+{
+  return rij_secondOrderMoments_;
+}
 
 void beam2Moments::impression() const {

Interface_Web/trunk/pspaWT/sources/controler/src/dataManager.cc

@@ -78 +78 @@
   string workingDir = pspa_->getWorkingDir();
   
-
   // Main loop !
-  for(unsigned k = 0; k < jobList_.size(); k++) {
-    sector* sector = jobList_[k];
-    
-    // for the moment, we put everything in one line without loops
-    for (unsigned int l=0; l <sector->getSectionsToExecute().size(); l++) {
-      sectionToExecute* section = sector->getSectionsToExecute()[l];
-      abstractSoftware* softw = section->getSoftware();
+  cout << " dataManager::executeAll #jobList_= " << jobList_.size() << endl;
+  for(unsigned k = 0; k < jobList_.size(); k++) 
+    {
+      sector* sector = jobList_[k];
+      cout << " dataManager::executeAll sector name= " << sector->getName() << endl;
+      cout << " dataManager::executeAll #sectionsToExecute= " << sector->getSectionsToExecute().size() << endl;
       
-#if BAVARD > 0
-    cout << " dataManager::executeAll je m'apprete a executer : " << (jobList_[k]->getSoftware()->getName()) << endl;
-#endif
-      
+      // for the moment, we put everything in one line without loops
+      for(unsigned int l = 0; l < sector->getSectionsToExecute().size(); l++) 
+        {
+          sectionToExecute* section = sector->getSectionsToExecute()[l];
+          abstractSoftware* softw = section->getSoftware();
+          
       //cout << "k= " << k << ", de " << jobList_[k]->getFirstElement()->getLabel() << " Ã  " << jobList_[k]->getLastElement()->getLabel() << " avec " << softw->getName() << endl;
       
@@ -99 +99 @@
       break;
     }
-      // END OF FIXME
-      success = softw->createInputFile(sector->getParticleBeam(),workingDir);
+    
+    success = softw->createInputFile(sector->getParticleBeam(),workingDir);
     if ( success ) {
       success = softw->execute(workingDir);
@@ -110 +110 @@
     if ( success  && (diagnosticBeam_.size() > 0)) {
       sector->setParticleBeam(&diagnosticBeam_.at(indexElementToIndexDiag_.back()));
-      cout << " execute termine avec succes " << endl;
+      cout << " dataManager::executeAll termine avec succes " << endl;
     } else {
       sector->setParticleBeam(NULL);
-      cout << " execute termine en ECHEC " << endl;
+      cout << " dataManager::executeAll termine en ECHEC " << endl;
     }
     if ( !success ) break;
     
 #if BAVARD > 0
-      cout << "dataManager::executeAll #diagnosticBeam= " << diagnosticBeam_.size() << endl;
-      cout << "dataManager::executeAll #getBeamLineSize()= " << getBeamLineSize() << endl;
-      std::vector< abstractElement* > elements = section->getElements();
-      for (unsigned j = 0; j < elements.size(); j++) {
-        cout << "[" << j << "] " << elements[j]->getNomdElement().getExpandedName() << endl;
-      }
+          cout << "dataManager::executeAll #diagnosticBeam= " << diagnosticBeam_.size() << endl;
+          cout << "dataManager::executeAll #getBeamLineSize()= " << getBeamLineSize() << endl;
+          std::vector< abstractElement* > elements = section->getElements();
+          for (unsigned j = 0; j < elements.size(); j++) {
+            cout << "[" << j << "] " << elements[j]->getNomdElement().getExpandedName() << endl;
+          }
 #endif
-    } //l
-  } //k
+        } //l
+    } //k
+  
   // if ( currentBeam_deprecated_ ) {
   // string aml_file = workingDir + "/" + "faisceau_final" + ".aml";
@@ -133 +134 @@
   //   currentBeam_deprecated_->readFromAMLFile(aml_file);
   // }
-  cout << " dataManager::executeAll() " << endl;
-
+ 
   return success;
 }

Interface_Web/trunk/pspaWT/sources/controler/src/particleBeam.cc

@@ -357 +357 @@
   vector<double> part(6, 0.0);
 
-    vector< vector<double> >& matrice = rij_.getMatrix();
+  vector< vector<double> >& matrice = rij_.getMatrix();
 
     TRIDVECTOR positionDeployee;

Interface_Web/trunk/pspaWT/sources/controler/src/softwareMadx.cc

@@ -3 +3 @@
 #include "dataManager.h"
 
+#include "mathematicalConstants.h"
+#include "PhysicalConstants.h"
+
 softwareMadx::softwareMadx() : abstractSoftware()
 {
@@ -12 +15 @@
   nameOfSoftware_ = nomDeLogiciel("madx");
 
+ registerElement(nomdElements::RFgun,TBoolOk);
   registerElement(nomdElements::drift,TBoolOk);
   registerElement(nomdElements::mpole,TBoolOk);
 }
 
-bool softwareMadx::createInputFile(particleBeam* beamBefore, string workingDir)
+bool softwareMadx::createInputFile(particleBeam* beamBefore,string workingDir)
 {
   cout << "***********************************" << endl;
   cout << " softwareMadx::createInputFile(...) " << endl << endl;
-
   dataManager_->consoleMessage(" softwareMadx::createInputFile");
 
@@ -32 +35 @@
   }
 
-  cout << " softwareMadx::createInputFile(...) lecture des elts " << endl;
-  
+  sector* sector= getSectionToExecute()->getSector();
+  cout << " softwareMadx::createInputFile sector " << sector->getName() << endl;
+  ///////////////////////////////////////////
+  
+  unsigned firstIndex= 0;
+  string sbeam;
+  abstractElement* elPtr;
+  elPtr = getSectionToExecute()->getElements().front();
+
+  // le 1er elt n'est pas RFGun
+  if(elPtr->getNomdElement().getElementType() != nomdElements::RFgun) {
+    
+    if(beamBefore == NULL) { 
+      // il n'y a pas de faisceau : erreur
+      dataManager_->consoleMessage(" softwareMadx::createInputFile : no input beam, input file not created");
+      return false;
+    } else { 
+      // il y a un faisceau : on le met au format madx
+      dataManager_->consoleMessage(" softwareMadx::createInputFile : extract from input beam the quantities to be supplied to the madx BEAM command");
+      
+      if (beamBefore->particleRepresentationOk()) {
+        // le faisceau est représenté à la "parmela"
+        cout << "passsage de la représentation macroparticules à la representation moments" << endl;
+        beamBefore->buildMomentRepresentation();
+      } else if(beamBefore->momentRepresentationOk()) {
+        // le faisceau est représenté à la "transport"
+        cout << "le faisceau est représenté par moments" << endl;
+      } else {
+        // représentation ni "macroparticules" ni "moments"
+        dataManager_->consoleMessage(" softwareMadx::createInputFile : that's unclear: the beam is represented neither by macroparticles neither by moments");
+        return false;
+      }
+
+      sbeam = BEAMcommand(beamBefore);
+    }
+    
+    // le 1er elt est RFGun
+  } else {
+     firstIndex = 1;
+    dataManager_->consoleMessage(" softwareMadx::createInputFile : set from RF cavity the quantities to be supplied to the madx BEAM command");
+    sbeam = RFGunData(elPtr->parametersToSoftware());
+  }
+  ///////////////////////////////////////////
+
   // element label //////////////////////////
-
   outfile << endl; // saut de ligne
 
-  abstractElement* elPtr;
-  std::vector <abstractElement*> elements = getSectionToExecute()->getElements();
-  for(unsigned k = 0; k < elements.size(); k++)
+  ostringstream os;
+  os << "L: line=(";
+  unsigned nElts= getSectionToExecute()->getElements().size();
+  for(unsigned k = firstIndex; k < nElts; k++)
     {
-      elPtr = elements[k];
-      //cout << " debug:: element [" << k << "] " << elPtr->getNomdElement().getExpandedName() << endl;
+      elPtr = getSectionToExecute()->getElements()[k];
+      cout << " debug:: element [" << k << "] " << elPtr->getNomdElement().getExpandedName() << endl;
       vector<statements> v= elPtr->parametersToSoftware();
       outfile << inputFormat(v);
-    }
-
-  // sublines ///////////////////////////////
-
+
+      if(k < nElts-1) 
+        os << elPtr->getLabel() << ",";
+      else
+        os << elPtr->getLabel() << ");" << endl;
+    }
+
+  // lines/sublines ///////////////////////////////
   outfile << endl; // saut de ligne
-
-  //_______________________________________________________
-  // FIXME Francois !!!!!
-  //_______________________________________________________
- /*
-  vector<statements> u = sectParamPtr_->getSectors();
-  for(unsigned int i = 0; i < u.size(); i++) {
-    ostringstream os;
-    os << u.at(i).first << ": line=(";
-    unsigned ai = dataManager_->getNumeroFromElementLabel(u.at(i).second.at(0));
-    unsigned bi = dataManager_->getNumeroFromElementLabel(u.at(i).second.at(1));
-
-    std::vector <abstractElement*> elements = getSectionToExecute()->getElements();
-    for(unsigned k = 0; k < elements.size(); k++) {
-      elPtr = elements[k];
-      
-      if(k >= ai && k <= bi) { 
-        if(k == bi) 
-          os << elPtr->getLabel() <<");";
-        else
-          os << elPtr->getLabel() <<",";
-      }
-    }// k
-
-    outfile << os.str() << endl; 
-  }// i
-
+  
   // relection and repetition ///////////////
-
+  os << "all: " << "line=(" << sector->getRepetitionNumber() << "*L);";
+  ///////////////////////////////////////////
+  
+  outfile << os.str() << endl;
   outfile << endl; // saut de ligne
-
-  string *str= NULL;
-  if(u.size() > 0) {
-    str = new string[u.size()];
-    for(unsigned int i = 0; i < u.size(); i++) str[i]= "false";
-  }
-
-  ostringstream os;
-  os << "all: " << "line=(";
-  for(unsigned k = 0; k < elements.size(); k++) {
-    elPtr = elements[k];
-    bool isMember = false;
-
-    for(unsigned int i = 0; i < u.size(); i++) {
-      unsigned ai = dataManager_->getNumeroFromElementLabel(u.at(i).second.at(0));
-      unsigned bi = dataManager_->getNumeroFromElementLabel(u.at(i).second.at(1));
-      if(k >= ai && k <= bi) {
-        isMember = true;
-
-        if(str[i] == "false") {
-          //int reflection = atoi(u.at(i).second.at(2).c_str());
-          int reflection = ( (u.at(i).second.at(2) == "Unchecked") ? 0:1 );
-          int repeat = atoi(u.at(i).second.at(3).c_str());
-          if(reflection > 0)
-            os << "-" << repeat << "*" << u.at(i).first;
-          else
-            os << repeat << "*" << u.at(i).first;
-
-          if(i < u.size()-1) os << ", ";
-        }
-
-        str[i] = "true";
-        break;
-      }
-    }// i
-    
-    if(isMember && k == (elements.size()-1)) os << ");";
-    
-    if(!isMember) {
-      if(k == (elements.size()-1)) os << elPtr->getLabel() << ");";
-      else os << elPtr->getLabel() << ",";
-    }
-  }// k
-
-  outfile << os.str() << endl;
-  ///////////////////////////////////////////
-      
-  outfile << endl; // saut de ligne
-
-  outfile << "beam;" << endl; // beam data p46
+  ///////////////////////////////////////////
+
+  outfile << sbeam << endl; // beam commnd p46
   outfile << "use, period = all;" << endl << endl; // action commands p45
   
@@ -137 +116 @@
   outfile << "stop;" << endl;
 
-  */
-  //_______________________________________________________
-  // FIXME Francois !!!!!
-  //_______________________________________________________
-
   outfile.close();
   dataManager_->consoleMessage("input file done for madx");
   return true;
+}
+
+string softwareMadx::BEAMcommand(particleBeam* beam) const 
+{
+  // le 20 décembre : les commandes BEAM de madx sont :
+  // PARTICLE (defaut POSITRON)
+  // ENERGY (defaut 1 GeV) ou bien PC GeV/c
+  // EX et EY (defaut 1 m.rad)
+  // ET (defaut 1 m)
+
+  ostringstream os;
+  os << "beam, PARTICLE = ELECTRON";
+
+  double pc = beam->getP0Transport();
+  os << ", ENERGY = " << pc; // en GeV
+
+  const beam2Moments& mts = beam->getTransportMoments();
+  const vector< vector<double> > rij= mts.getMoments();
+
+  // emittance (x,x')
+  double r10= rij.at(1).at(0); // r10 et s10 = s01= r10*r00*r11
+  double rac= 0.0;
+  if(r10*r10 < 1.0) rac= sqrt(1.0-r10*r10);
+  double EX = rij.at(0).at(0)*rij.at(1).at(1)*rac; // r00*r11*sqrt(1-s01*s10)
+  // r00 en cm (= 1E-02 m) et r11 en mrad (= 1E-03 rad)
+  os << ", EX = " << EX*1.E-05;
+
+  // emittance (y,y')
+  double r32= rij.at(3).at(2); // r32 et s32 = s23= r32*r22*r33
+  rac= 0.0;
+  if(r32*r32 < 1.0) rac= sqrt(1.0-r32*r32);
+  double EY = rij.at(2).at(2)*rij.at(3).at(3)*rac; // r22*r33*sqrt(1-s23*s32)
+  os << ", EY = " << EY*1.E-05;
+
+  os << ";";
+  return os.str();
+}
+
+string softwareMadx::RFGunData(const vector<statements>& v) const 
+{
+  //NPART = v.at(1).second.at(0);
+  //SIGT (m) = v.at(2).second.at(0) (ps)
+  //?? = sigma_r = v.at(2).second.at(1); en cm
+  //EX (m.rad) = v.at(3).second.at(0) (pi.mm.mrad)
+  //EY (m.rad) = v.at(3).second.at(1) (pi.mm.mrad) 
+  //ENERGY (GeV) = v.at(4).second.at(0) (MeV)
+  //SIGE (GeV) = v.at(4).second.at(1) (MeV)
+  //CHARGE = v.at(6).second.at(0);
+
+  ostringstream os;
+  os << "beam, PARTICLE = ELECTRON";
+
+  // masse au repos (en GeV) E0 = 1.E-03*EREST_MeV
+  // energie cinetique (en GeV) T = 1.E-03*E_cin
+  // l'energie totale  (en Gev) W = E0+T
+  double W = 1.E-03*(EREST_MeV + atof(v.at(4).second.at(0).c_str()));
+  os << ", ENERGY = " << W; // total energy in [Gev]
+
+  // pi*EX = 1E-06*emit_x en pi.m.rad
+  double EX = 1.E-06*atof(v.at(3).second.at(0).c_str())/PI;
+  os << ", EX = " << EX; // horizontal emittance in [rad.m]
+  double EY = 1.E-06*atof(v.at(3).second.at(1).c_str())/PI;
+  os << ", EY = " << EY; // vertical emittance in [rad.m]
+
+  // SIGT = c*sigma_t*1E-12
+  double SIGT = 1.E-04*CLIGHT_E8*atof(v.at(2).second.at(0).c_str());
+  os << ", SIGT = " << SIGT; // bunch length in [m]
+
+  // SIGE = sigma_Ecin/(p0*c) ou p0 impulsion de la paricule de réf. 
+  // os << ", SIGE = " << atof(v.at(4).second.at(1).c_str());
+
+  os << ";";
+  return os.str();
 }
 
@@ -216 +263 @@
 }
 
+// bool softwareMadx::execute(string workingDir)
+// {
+//   cout << "***********************************" << endl;
+//   cout << " softwareMadx::execute(...) " << endl << endl;
+
+//   dataManager_->consoleMessage(" softwareMadx::execute");
+//   return false;
+// }
+
 bool softwareMadx::buildBeamAfterElements(string workingDir)
 {
@@ -221 +277 @@
   cout << " softwareMadx::buildBeamAfterElements(...) " << endl << endl;
 
-  dataManager_->consoleMessage(" softwareMadx::buildBeamAfterElements");
+  dataManager_->consoleMessage(" softwareMadx::buildBeamAfterElements: not programmed :O((");
   return false;
 }