Changeset 482 in PSPA for Interface_Web/trunk/pspaWT/sources/controler/src/softwareMadx.cc

Timestamp:

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

Author:

touze

Message:

maj dans le fichier d'appel de madx

File:

• Interface_Web/trunk/pspaWT/sources/controler/src/softwareMadx.cc (modified) (6 diffs)

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;
 }