Changeset 42 in PSPA for Interface_Web/trunk/pspaWT/include


Ignore:
Timestamp:
Oct 28, 2012, 5:33:22 PM (12 years ago)
Author:
lemeur
Message:

creation de fichiers cc

Location:
Interface_Web/trunk/pspaWT/include
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • Interface_Web/trunk/pspaWT/include/elementCell.h

    r41 r42  
    22#define ELEMENTCELL_SEEN
    33
    4 #include <iostream>
    54#include <string>
    65#include "abstractElement.h"
    7 #include "mathematicalTools.h"
    8 #include "mixedTools.h"
    96
    10 using namespace std;
    117
    128
    … …  
    3531
    3632
    37   void setDefaultValues()
    38   {
    39     initialPhaseDef_ = 0.0;
    40     acceleratingFieldDef_ = 1.0;
    41     acceleratingShapeFileDef_ = string(" ");
    42     focusingMagFileDef_ = string(" ");
    43     offsetMagDef_ = 0.0;
    44     scaleFactorDef_ = 1.0;
    45   }
     33  void setDefaultValues();
    4634
    47   void setDefaults()
    48   {
    49     initialPhase_ = initialPhaseDef_;
    50     acceleratingField_ = acceleratingFieldDef_;
    51     acceleratingShapeFile_ = acceleratingShapeFileDef_;
    52     focusingMagFile_ = focusingMagFileDef_;
    53     offsetMag_ = offsetMagDef_;
    54     scaleFactor_ = scaleFactorDef_;
    55   }
     35  void setDefaults();
     36
    5637 public :
    5738
    58   elementCell()  : abstractElement()
    59     {
    60       label_ = string("");
    61       setDefaultValues();
    62       setDefaults();
    63       elementName_ = cell;
    64       nbParam_ = 9;
    65       parametersString_ = new string[nbParam_+1];
    66     }
     39  elementCell();
    6740
    6841
    … …  
    7043
    7144
    72   virtual string* getParametersString() const
    73   {
    74     parametersString_[0] = mixedTools::intToString(nbParam_);
    75     parametersString_[1] = mixedTools::doubleToString(lenghtElem_);
    76     parametersString_[2] = mixedTools::doubleToString(aperture_);
    77     parametersString_[3] = mixedTools::doubleToString(initialPhase_);
    78     parametersString_[4] = mixedTools::doubleToString( phaseStepMax_);
    79     parametersString_[5] = mixedTools::doubleToString(acceleratingField_);
    80     parametersString_[6] = acceleratingShapeFile_;
    81     parametersString_[7] = focusingMagFile_;
    82     parametersString_[8] = mixedTools::doubleToString(offsetMag_);
    83     parametersString_[9] = mixedTools::doubleToString(scaleFactor_);
     45  virtual string* getParametersString() const;
    8446
    85     return parametersString_;
    86   }
     47 virtual void setParametersString(string* param);
    8748
    88   virtual void setParametersString(string* param)
    89   {
    90     if ( param == NULL )
    91       {
    92         cerr << "  elementCell::setParametersString parameters empty parameter set";
    93         return;
    94       }
    95     int nbparam = atoi(param[0].c_str());
    96     if ( nbparam != nbParam_ )
    97       {
    98         cerr << "  elementCell::setParametersString parameters do not match for a CELL";
    99         return;
    100       }
    101 
    102     lenghtElem_ = atof(param[1].c_str());
    103     aperture_ = atof(param[2].c_str());
    104     initialPhase_ = atof(param[3].c_str());
    105     phaseStepMax_ = atof(param[4].c_str());
    106     acceleratingField_ = atof(param[5].c_str());
    107     acceleratingShapeFile_ = param[6];
    108     focusingMagFile_ = param[7];
    109     offsetMag_ = atof(param[8].c_str());
    110     scaleFactor_ = atof(param[9].c_str());
    111   }
    112 
    113 virtual  string parmelaOutputFlow() const
    114   {
    115     ostringstream sortie;
    116     // on prend les troncatures tmax et rmax à 3 sigmas
    117     sortie << "CELL /l=" << lenghtElem_ << "  /aper=" << aperture_ << endl;
    118     sortie << "  /iout=1  /phi0=" << initialPhase_ << " /E0=" << acceleratingField_ << endl;
    119     sortie << " /nc=1 /dwtmax=" << phaseStepMax_ << " /sym=-1" << endl;
    120     sortie << "CFIELD 1" << endl;
    121     sortie << acceleratingShapeFile_ << endl;
    122     sortie << "POISSON /zoff=" << offsetMag_ << " /rmult=" << scaleFactor_ << endl;
    123     sortie << focusingMagFile_ << endl;
    124 
    125     return sortie.str();
    126   }
     49  virtual  string parmelaOutputFlow() const;
    12750
    12851

  • Interface_Web/trunk/pspaWT/include/elementDrift.h

    r41 r42  
    22#define DRIFTDEFINITION_SEEN
    33
    4 #include <iostream>
    5 #include <string>
    64#include "abstractElement.h"
    7 #include "mathematicalTools.h"
    8 #include "mixedTools.h"
    95
    10 using namespace std;
    116
    127
    … …  
    1914 public:
    2015
    21  elementDrift() : abstractElement()
    22 {
    23   elementName_ = drift;
    24   nbParam_ = 2;
    25   parametersString_ = new string[nbParam_+1];
    26 }
     16  elementDrift();
    2717
    28  elementDrift(string lab) : abstractElement(lab)
    29  {
    30    elementName_ = drift;
    31   nbParam_ = 2;
    32   parametersString_ = new string[nbParam_+1];
    33 }
    3418
    3519  ~elementDrift() {;}
    3620
    37  virtual string* getParametersString() const
    38  {
    39    std::cout << " getParametersString long= " << lenghtElem_ << " ouv= " << aperture_ << std::endl;
    40    parametersString_[0] = mixedTools::intToString(nbParam_);
    41    parametersString_[1] = mixedTools::doubleToString(lenghtElem_);
    42    parametersString_[2] = mixedTools::doubleToString(aperture_);
    43    return parametersString_;
    44  }
     21  virtual string* getParametersString() const;
    4522
    46  virtual void setParametersString(string* param)
    47  {
    48         if ( param == NULL )
    49         {
    50           cerr << "  elementDrift::setParametersString parameters empty parameter set";
    51           return;
    52         }
    53         int nbparam = atoi(param[0].c_str());
    54     if ( nbparam != nbParam_ )
    55         {
    56           cerr << "  elementDrift::setParametersString parameters do not match for a DRIFT";
    57           return;
    58         }
    59     lenghtElem_ = atof(param[1].c_str());
    60     aperture_  = atof(param[2].c_str());
    61  }
     23  virtual void setParametersString(string* param);
    6224
    63 virtual  string parmelaOutputFlow() const
    64   {
    65     ostringstream sortie;
    66     sortie << "DRIFT /l=" << lenghtElem_ << "  /aper=" << aperture_ << "  /iout=1";
    67     return sortie.str();
    68   }
     25  virtual  string parmelaOutputFlow() const;
    6926
    7027};

  • Interface_Web/trunk/pspaWT/include/elementInitialBeam.h

    r41 r42  
    22#define INITIALBEAMDEFINITION_SEEN
    33
    4 #include <iostream>
    54#include <string>
    65#include "abstractElement.h"
    7 #include "mathematicalTools.h"
    8 #include "mixedTools.h"
    9 
    10 using namespace std;
    116
    127
    … …  
    3126  double nb_true_particles_;
    3227
    33   void setDefaultValues()
    34   {
    35     defaultNmacrop_ = 0;
    36     defaultSigma_t_ = 0.0;
    37     defaultSigma_r_ = 0.0;
    38     defaultE_cin_ = 0.0;
    39     defaultSigma_E_ = 0.0;
    40     defaultNb_true_particles_ = 0.0;
    41   }
     28  void setDefaultValues();
    4229 
    43   void setDefaults()
    44   {
    45     nmacrop_ = defaultNmacrop_;
    46     sigma_t_ = defaultSigma_t_;
    47     sigma_r_ = defaultSigma_r_ ;
    48     E_cin_ = defaultE_cin_;
    49     sigma_E_ = defaultSigma_E_;
    50     nb_true_particles_ = defaultNb_true_particles_ ;
    51       cout << " initialBeam setDefaults " <<  nbParam_ << " nmacro " << nmacrop_ << endl;
    52   }
     30  void setDefaults();
     31
    5332 public:
    5433
    55  elementInitialBeam() : abstractElement()
    56     {
    57       label_ = string("");
    58       setDefaultValues();
    59       setDefaults();
    60       elementName_ = initialBeam;
    61       nbParam_ = 6;
    62       parametersString_ = new string[nbParam_+1];
    63       cout << " initialBeam constructeur " <<  nbParam_ << " nmacro " << nmacrop_ << endl;
    64     }
     34  elementInitialBeam();
    6535
    6636  ~elementInitialBeam() {;}
    6737
    6838
    69   virtual string* getParametersString() const
    70   {
    71     cout << " initialBeam j'envoie " <<  nbParam_ << " nmacro " << nmacrop_ << endl;
    72     parametersString_[0] = mixedTools::intToString(nbParam_);
    73     parametersString_[1] = mixedTools::intToString(nmacrop_);
    74     parametersString_[2] = mixedTools::doubleToString(sigma_t_);
    75     parametersString_[3] = mixedTools::doubleToString(sigma_r_);
    76     parametersString_[4] = mixedTools::doubleToString(E_cin_);
    77     parametersString_[5] = mixedTools::doubleToString(sigma_E_);
    78     parametersString_[6] = mixedTools::doubleToString(nb_true_particles_);
    79     return parametersString_;
    80   }
     39  virtual string* getParametersString() const;
    8140
    82   virtual void setParametersString(string* param)
    83   {
    84     if ( param == NULL )
    85       {
    86         cerr << "  elementInitialBeam::setParametersString parameters empty parameter set";
    87         return;
    88       }
    89     int nbparam = atoi(param[0].c_str());
    90     if ( nbparam != nbParam_ )
    91       {
    92         cerr << "  elementInitialBeam::setParametersString parameters do not match for a DRIFT";
    93         return;
    94       }
     41  virtual void setParametersString(string* param);
    9542
    96     nmacrop_ = atoi(param[1].c_str());
    97     sigma_t_ = atof(param[2].c_str());
    98     sigma_r_ = atof(param[3].c_str());
    99     E_cin_ = atof(param[4].c_str());
    100     sigma_E_ = atof(param[5].c_str());
    101     nb_true_particles_ = atof(param[6].c_str());
     43 virtual inline double getInitialKineticEnergy() const {return E_cin_;}
    10244
    103   }
    104 
    105  virtual double getInitialKineticEnergy() const {return E_cin_;}
    106 
    107 virtual  string parmelaOutputFlow() const
    108   {
    109     ostringstream sortie;
    110     // on prend les troncatures tmax et rmax à 3 sigmas
    111     sortie << "INPUT 10 /np=" << nmacrop_ << "  /sigt=" << sigma_t_ << endl;
    112     sortie << "  /tmax=" << 3.3*sigma_t_ << " /sigr=" << sigma_r_ << endl;
    113     sortie << " /rmax=" << 3.0*sigma_r_ << " /W0=" << E_cin_ << " /dw0=" << sigma_E_ << endl;
    114     sortie << " /dwt=" << phaseStep_ << " /ran=2" << endl;
    115 
    116     sortie << "SCHEFF /beami=" << -defaultNb_true_particles_ << " /nprog=2 /point=-1.7";
    117  
    118     return sortie.str();
    119   }
     45 virtual string parmelaOutputFlow() const;
    12046
    12147};

  • Interface_Web/trunk/pspaWT/include/globalParameters.h

    r38 r42  
    44#include <iostream>
    55#include <string>
    6 //#include "mathematicalTools.h"
    7 #include "mixedTools.h"
     6
     7
     8using namespace std;
    89
    910class globalParameters
    … …  
    3940   nsc_ = nscDef_;
    4041 }
     42
     43
     44
    4145public:
    42  globalParameters() : parametersString_(NULL)
    43    {
    44      setDefaultValues();
    45      setDefaults();
    46      nbParam_ = 4;
    47      parametersString_ = new string[nbParam_+1];
    48    }
     46 globalParameters();
    4947
    5048 ~globalParameters()
    5149{
    5250  if ( parametersString_ != NULL) delete [] parametersString_;
    53 ;
    5451}
    5552
    … …  
    6057 inline int getScPeriod() const {return nsc_;}
    6158
    62  string* getParametersString() const
    63 
    64  {
    65    parametersString_[0] = mixedTools::intToString(nbParam_);
    66    parametersString_[1] = mixedTools::doubleToString(frequency_);
    67    parametersString_[2] = mixedTools::doubleToString(integrationStep_);
    68    parametersString_[3] = mixedTools::intToString( nstepsMax_);
    69    parametersString_[4] = mixedTools::intToString( nsc_);
    70    return parametersString_;
    71  }
     59  string* getParametersString() const;
    7260
    7361
    74  void setParametersString(string* param)
    75  {
    76         if ( param == NULL )
    77         {
    78           cerr << "  globalParameters::setParametersString parameters empty parameter set";
    79           return;
    80         }
    81         int nbparam = atoi(param[0].c_str());
    82     if ( nbparam != 4 )
    83         {
    84           cerr << "  globalParameters::setParametersString parameters do not match for globalParameters";
    85           return;
    86         }
    87     frequency_ = atof(param[1].c_str());
    88     integrationStepDef_  = atof(param[2].c_str());
    89     nstepsMax_ = atoi(param[3].c_str());
    90     nsc_ = atoi(param[4].c_str());
    91  }
     62 void setParametersString(string* param);
    9263
    9364};
Note: See TracChangeset for help on using the changeset viewer.