diff --git a/CMakeLists.txt b/CMakeLists.txt
index d46985f36c1dee7ad01b648804f570ca12f0e1b0..5ce86aefbbe5d8604550599ca069ad3515e0af1e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -320,4 +320,4 @@ install (
FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config_install.cmake
DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/cmake/${PROJECT_NAME}"
RENAME ${PROJECT_NAME}Config.cmake
- )
+ )
\ No newline at end of file
diff --git a/optimizer/Expression/Parser/evaluator.hpp b/optimizer/Expression/Parser/evaluator.hpp
index 62c579ff6e005570a2150b27d475cd6f3329d829..79274a27f6e81135315363f6d356f8836976624f 100644
--- a/optimizer/Expression/Parser/evaluator.hpp
+++ b/optimizer/Expression/Parser/evaluator.hpp
@@ -14,9 +14,9 @@
#include <boost/assert.hpp>
#include <boost/variant/get.hpp>
#include <boost/variant/variant.hpp>
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_function.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/phoenix/core.hpp>
+#include <boost/phoenix/function.hpp>
+#include <boost/phoenix/operator.hpp>
#include "ast.hpp"
#include "function.hpp"
diff --git a/optimizer/Expression/Parser/expression_def.hpp b/optimizer/Expression/Parser/expression_def.hpp
index e2f78bf5dffa58b7df69fe411355adda738e05ee..f0e984d7aa3cd578c39d4ab647237f0b41c663ef 100644
--- a/optimizer/Expression/Parser/expression_def.hpp
+++ b/optimizer/Expression/Parser/expression_def.hpp
@@ -7,8 +7,8 @@
#include "expression.hpp"
#include "error_handler.hpp"
#include "annotation.hpp"
-#include <boost/spirit/include/phoenix_function.hpp>
-#include <boost/spirit/include/phoenix.hpp>
+#include <boost/phoenix/function.hpp>
+#include <boost/phoenix.hpp>
#include <boost/fusion/adapted.hpp>
//#include <boost/spirit/include/qi_lit.hpp>
@@ -190,4 +190,4 @@ namespace client { namespace parser
on_success(primary_expr,
annotation_function(error_handler.iters)(_val, _1));
}
-}}
\ No newline at end of file
+}}
diff --git a/optimizer/Expression/Parser/requirements.hpp b/optimizer/Expression/Parser/requirements.hpp
index 78c5d0f41ba92458b6e619fc87b3e522116e23cb..ed2bc611549b199aee239241a86dc705b3e792b2 100644
--- a/optimizer/Expression/Parser/requirements.hpp
+++ b/optimizer/Expression/Parser/requirements.hpp
@@ -12,9 +12,9 @@
#include <set>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_function.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
+#include <boost/phoenix/core.hpp>
+#include <boost/phoenix/function.hpp>
+#include <boost/phoenix/operator.hpp>
namespace client { namespace code_gen
{
diff --git a/optimizer/Util/SDDSParser/array_def.hpp b/optimizer/Util/SDDSParser/array_def.hpp
index 3bf586e992ada591d81b0b0aabb55436da1cb91a..3b2301780b829d517ba044e487c05d3ee5e43468 100644
--- a/optimizer/Util/SDDSParser/array_def.hpp
+++ b/optimizer/Util/SDDSParser/array_def.hpp
@@ -19,10 +19,10 @@
#include "array.hpp"
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/phoenix_fusion.hpp>
-#include <boost/spirit/include/phoenix_bind.hpp>
+#include <boost/phoenix/core.hpp>
+#include <boost/phoenix/operator.hpp>
+#include <boost/phoenix/fusion.hpp>
+#include <boost/phoenix/bind.hpp>
namespace SDDS { namespace parser
{
diff --git a/optimizer/Util/SDDSParser/associate.hpp b/optimizer/Util/SDDSParser/associate.hpp
index 1cd05f1829a4272aa2e75c7737f050225e3fbcb5..e4eabb22b98348d1cf6a3061db27c10531f2bd4e 100644
--- a/optimizer/Util/SDDSParser/associate.hpp
+++ b/optimizer/Util/SDDSParser/associate.hpp
@@ -23,10 +23,10 @@
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/phoenix_fusion.hpp>
-#include <boost/spirit/include/phoenix_bind.hpp>
+#include <boost/phoenix/core.hpp>
+#include <boost/phoenix/operator.hpp>
+#include <boost/phoenix/fusion.hpp>
+#include <boost/phoenix/bind.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <list>
diff --git a/optimizer/Util/SDDSParser/associate_def.hpp b/optimizer/Util/SDDSParser/associate_def.hpp
index 6ce7d39896764e4debe227449cae18f5491b1941..01d0bb72bc9aed4ef64e748ad7f85f8347532d52 100644
--- a/optimizer/Util/SDDSParser/associate_def.hpp
+++ b/optimizer/Util/SDDSParser/associate_def.hpp
@@ -19,10 +19,10 @@
#include "associate.hpp"
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/phoenix_fusion.hpp>
-#include <boost/spirit/include/phoenix_bind.hpp>
+#include <boost/phoenix/core.hpp>
+#include <boost/phoenix/operator.hpp>
+#include <boost/phoenix/fusion.hpp>
+#include <boost/phoenix/bind.hpp>
namespace SDDS { namespace parser
{
diff --git a/optimizer/Util/SDDSParser/column_def.hpp b/optimizer/Util/SDDSParser/column_def.hpp
index d309a27d28d643a05ce33f64520890607a80a8e3..a664943ee419524211810b4ed5588457bf892ddb 100644
--- a/optimizer/Util/SDDSParser/column_def.hpp
+++ b/optimizer/Util/SDDSParser/column_def.hpp
@@ -19,11 +19,11 @@
#include "column.hpp"
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/phoenix_fusion.hpp>
-#include <boost/spirit/include/phoenix_object.hpp>
-#include <boost/spirit/include/phoenix_bind.hpp>
+#include <boost/phoenix/core.hpp>
+#include <boost/phoenix/operator.hpp>
+#include <boost/phoenix/fusion.hpp>
+#include <boost/phoenix/object.hpp>
+#include <boost/phoenix/bind.hpp>
namespace SDDS { namespace parser
{
diff --git a/optimizer/Util/SDDSParser/data_def.hpp b/optimizer/Util/SDDSParser/data_def.hpp
index bb3c09da4d6c0592f8fe825ba56e96629ebfd51f..c226565a67da00ba1ed71f0ca889be114394e293 100644
--- a/optimizer/Util/SDDSParser/data_def.hpp
+++ b/optimizer/Util/SDDSParser/data_def.hpp
@@ -19,10 +19,10 @@
#include "data.hpp"
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/phoenix_fusion.hpp>
-#include <boost/spirit/include/phoenix_bind.hpp>
+#include <boost/phoenix/core.hpp>
+#include <boost/phoenix/operator.hpp>
+#include <boost/phoenix/fusion.hpp>
+#include <boost/phoenix/bind.hpp>
namespace SDDS { namespace parser
{
diff --git a/optimizer/Util/SDDSParser/description_def.hpp b/optimizer/Util/SDDSParser/description_def.hpp
index 68e1e7dca4f2adab81eaa006af671dd0733a252e..8edcb3b710da272daa78d4df417791f46bfbfb8e 100644
--- a/optimizer/Util/SDDSParser/description_def.hpp
+++ b/optimizer/Util/SDDSParser/description_def.hpp
@@ -19,10 +19,10 @@
#include "description.hpp"
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/phoenix_fusion.hpp>
-#include <boost/spirit/include/phoenix_bind.hpp>
+#include <boost/phoenix/core.hpp>
+#include <boost/phoenix/operator.hpp>
+#include <boost/phoenix/fusion.hpp>
+#include <boost/phoenix/bind.hpp>
namespace SDDS { namespace parser
{
diff --git a/optimizer/Util/SDDSParser/file_def.hpp b/optimizer/Util/SDDSParser/file_def.hpp
index d18482961b66b75f8682f975df92ce7a78133e5c..e3255074e35208e38590b3b81d160cf4390836ce 100644
--- a/optimizer/Util/SDDSParser/file_def.hpp
+++ b/optimizer/Util/SDDSParser/file_def.hpp
@@ -19,12 +19,12 @@
#include "file.hpp"
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/phoenix_fusion.hpp>
-#include <boost/spirit/include/phoenix_stl.hpp>
-#include <boost/spirit/include/phoenix_object.hpp>
-#include <boost/spirit/include/phoenix_bind.hpp>
+#include <boost/phoenix/core.hpp>
+#include <boost/phoenix/operator.hpp>
+#include <boost/phoenix/fusion.hpp>
+#include <boost/phoenix/stl.hpp>
+#include <boost/phoenix/object.hpp>
+#include <boost/phoenix/bind.hpp>
namespace SDDS { namespace parser
{
diff --git a/optimizer/Util/SDDSParser/include.hpp b/optimizer/Util/SDDSParser/include.hpp
index 1350f0372ba4abc63e9d90ee33d2c62ef02a3dea..385d1590d457c03e33ea552c877068f38a350b14 100644
--- a/optimizer/Util/SDDSParser/include.hpp
+++ b/optimizer/Util/SDDSParser/include.hpp
@@ -23,10 +23,10 @@
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/phoenix_fusion.hpp>
-#include <boost/spirit/include/phoenix_bind.hpp>
+#include <boost/phoenix/core.hpp>
+#include <boost/phoenix/operator.hpp>
+#include <boost/phoenix/fusion.hpp>
+#include <boost/phoenix/bind.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <list>
diff --git a/optimizer/Util/SDDSParser/include_def.hpp b/optimizer/Util/SDDSParser/include_def.hpp
index 287fcabe4fd61c631e8b47e4131a7e2051b6a67a..d8adf3f923f9277658b287de97a3a6d26961cbc8 100644
--- a/optimizer/Util/SDDSParser/include_def.hpp
+++ b/optimizer/Util/SDDSParser/include_def.hpp
@@ -19,10 +19,10 @@
#include "include.hpp"
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/phoenix_fusion.hpp>
-#include <boost/spirit/include/phoenix_bind.hpp>
+#include <boost/phoenix/core.hpp>
+#include <boost/phoenix/operator.hpp>
+#include <boost/phoenix/fusion.hpp>
+#include <boost/phoenix/bind.hpp>
namespace SDDS { namespace parser
{
diff --git a/optimizer/Util/SDDSParser/parameter_def.hpp b/optimizer/Util/SDDSParser/parameter_def.hpp
index 70caf5944778a45c99984c44f725b8c625a4cba5..da5cea71e33eb77cd585f05b8d15c379faf3a017 100644
--- a/optimizer/Util/SDDSParser/parameter_def.hpp
+++ b/optimizer/Util/SDDSParser/parameter_def.hpp
@@ -19,11 +19,11 @@
#include "parameter.hpp"
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/phoenix_fusion.hpp>
-#include <boost/spirit/include/phoenix_object.hpp>
-#include <boost/spirit/include/phoenix_bind.hpp>
+#include <boost/phoenix/core.hpp>
+#include <boost/phoenix/operator.hpp>
+#include <boost/phoenix/fusion.hpp>
+#include <boost/phoenix/object.hpp>
+#include <boost/phoenix/bind.hpp>
namespace SDDS { namespace parser
{
diff --git a/optimizer/Util/SDDSParser/version_def.hpp b/optimizer/Util/SDDSParser/version_def.hpp
index 8a1b91079fbf6217d191bc3206925150bc946928..6b543826da913eef5d0d827cda54f513bb31a751 100644
--- a/optimizer/Util/SDDSParser/version_def.hpp
+++ b/optimizer/Util/SDDSParser/version_def.hpp
@@ -19,10 +19,10 @@
#include "version.hpp"
-#include <boost/spirit/include/phoenix_core.hpp>
-#include <boost/spirit/include/phoenix_operator.hpp>
-#include <boost/spirit/include/phoenix_fusion.hpp>
-#include <boost/spirit/include/phoenix_bind.hpp>
+#include <boost/phoenix/core.hpp>
+#include <boost/phoenix/operator.hpp>
+#include <boost/phoenix/fusion.hpp>
+#include <boost/phoenix/bind.hpp>
namespace SDDS { namespace parser
{
diff --git a/src/Classic/AbsBeamline/Bend2D.cpp b/src/Classic/AbsBeamline/Bend2D.cpp
index 2de908f43d80f10777368f17bd49fcd3e701bf8f..e6aae5b38918ca2c75fd57c718fcbf6b5b29b664 100644
--- a/src/Classic/AbsBeamline/Bend2D.cpp
+++ b/src/Classic/AbsBeamline/Bend2D.cpp
@@ -781,7 +781,7 @@ bool Bend2D::findIdealBendParameters(double chordLength) {
bool Bend2D::initializeFieldMap() {
- fieldmap_m = Fieldmap::getFieldmap(fileName_m, fast_m);
+ fieldmap_m = _Fieldmap::getFieldmap(fileName_m, fast_m);
if (fieldmap_m != nullptr) {
if (fileName_m != "1DPROFILE1-DEFAULT")
@@ -947,7 +947,7 @@ void Bend2D::readFieldMap(Inform &msg) {
msg << level2 << getName() << " using file ";
fieldmap_m->getInfo(&msg);
- Fieldmap::readMap(fileName_m);
+ _Fieldmap::readMap(fileName_m);
fieldmap_m->get1DProfile1EntranceParam(entranceParameter1_m,
entranceParameter2_m,
entranceParameter3_m);
diff --git a/src/Classic/AbsBeamline/BendBase.h b/src/Classic/AbsBeamline/BendBase.h
index 9e5d8d0a9a3c4c8158d107c207f03e2c2fff26d6..16fff1a7538f5b226066d47bf13056295842582e 100644
--- a/src/Classic/AbsBeamline/BendBase.h
+++ b/src/Classic/AbsBeamline/BendBase.h
@@ -2,11 +2,11 @@
#define CLASSIC_BENDBASE_H
#include "AbsBeamline/Component.h"
+#include "Fields/Definitions.h"
#include <vector>
#include <string>
-class Fieldmap;
class BendBase: public Component {
public:
@@ -53,7 +53,7 @@ protected:
double angle_m; ///< Bend angle
double entranceAngle_m; ///< Angle between incoming reference trajectory
///< and the entrance face of the magnet (radians).
- Fieldmap *fieldmap_m; ///< Magnet field map.
+ Fieldmap fieldmap_m; ///< Magnet field map.
const bool fast_m = false; ///< Flag to turn on fast field calculation.
double gap_m; ///< Full vertical gap of the magnets.
@@ -144,4 +144,4 @@ std::string BendBase::getFieldMapFN() const {
}
-#endif
\ No newline at end of file
+#endif
diff --git a/src/Classic/AbsBeamline/CCollimator.cpp b/src/Classic/AbsBeamline/CCollimator.cpp
index 9932b6bf605806990a88748ab58dd703a64ff4fd..dd96626abcfae960c17904d51a06d2f5b17b2070 100644
--- a/src/Classic/AbsBeamline/CCollimator.cpp
+++ b/src/Classic/AbsBeamline/CCollimator.cpp
@@ -153,7 +153,7 @@ void CCollimator::doFinalise() {
void CCollimator::print() {
if (RefPartBunch_m == nullptr) {
if (!informed_m) {
- std::string errormsg = Fieldmap::typeset_msg("BUNCH SIZE NOT SET", "warning");
+ std::string errormsg = _Fieldmap::typeset_msg("BUNCH SIZE NOT SET", "warning");
ERRORMSG(errormsg << endl);
if (Ippl::myNode() == 0) {
std::ofstream omsg("errormsg.txt", std::ios_base::app);
diff --git a/src/Classic/AbsBeamline/Cyclotron.cpp b/src/Classic/AbsBeamline/Cyclotron.cpp
index f59cbe8df81b0d6cd8178f37fc44201c7dc1cb77..7ac45c785d0f6b843b8f4c0e5301eac877f17389 100644
--- a/src/Classic/AbsBeamline/Cyclotron.cpp
+++ b/src/Classic/AbsBeamline/Cyclotron.cpp
@@ -477,7 +477,7 @@ bool Cyclotron::apply(const Vector_t& R, const Vector_t& /*P*/,
}
//The RF field is supposed to be sampled on a cartesian grid
- std::vector<Fieldmap *>::const_iterator fi = RFfields_m.begin();
+ std::vector<Fieldmap>::const_iterator fi = RFfields_m.begin();
std::vector<double>::const_iterator rffi = rffrequ_m.begin();
std::vector<double>::const_iterator rfphii = rfphi_m.begin();
std::vector<double>::const_iterator escali = escale_m.begin();
@@ -1404,7 +1404,7 @@ void Cyclotron::getFieldFromFile_BandRF(const double& scaleFactor) {
// read 3D E&B field data file
// loop over all field maps and superpose fields
for (auto& fm: RFfilename_m) {
- Fieldmap *f = Fieldmap::getFieldmap(fm, false);
+ Fieldmap f = _Fieldmap::getFieldmap(fm, false);
*gmsg << "* Reading '" << fm << "'" << endl;
f->readMap();
RFfields_m.push_back(f);
@@ -1431,7 +1431,7 @@ void Cyclotron::getFieldFromFile_Synchrocyclotron(const double& scaleFactor) {
*gmsg << "* ------------------------------------------------------------" << endl;
for (; fm != RFfilename_m.end(); ++fm, ++rffcfni, ++rfvcfni, ++fcount) {
- Fieldmap *f = Fieldmap::getFieldmap(*fm, false);
+ Fieldmap f = _Fieldmap::getFieldmap(*fm, false);
f->readMap();
// if (IPPL::Comm->getOutputLevel() != 0) f->getInfo(gmsg);
RFfields_m.push_back(f);
diff --git a/src/Classic/AbsBeamline/Cyclotron.h b/src/Classic/AbsBeamline/Cyclotron.h
index 5690f2460232ea139971ca99fff1f9b65271e966..156388a325544fc7c465f203a26cdaed23c4fafd 100644
--- a/src/Classic/AbsBeamline/Cyclotron.h
+++ b/src/Classic/AbsBeamline/Cyclotron.h
@@ -27,11 +27,11 @@
#define CLASSIC_Cyclotron_HH
#include "AbsBeamline/Component.h"
+#include "Fields/Definitions.h"
#include <string>
#include <vector>
-class Fieldmap;
class LossDataSink;
class TrimCoil;
@@ -283,8 +283,8 @@ private:
void operator=(const Cyclotron &) = delete;
// RF field map handler
- // Fieldmap *RFfield;
- std::vector<Fieldmap*> RFfields_m;
+ // Fieldmap RFfield;
+ std::vector<Fieldmap> RFfields_m;
std::vector<std::string> RFfilename_m;
std::vector<std::string> RFFCoeff_fn_m;
std::vector<std::string> RFVCoeff_fn_m;
@@ -302,4 +302,4 @@ protected:
BPositions BP_m;
};
-#endif // CLASSIC_Cyclotron_HH
+#endif // CLASSIC_Cyclotron_HH
\ No newline at end of file
diff --git a/src/Classic/AbsBeamline/FlexibleCollimator.cpp b/src/Classic/AbsBeamline/FlexibleCollimator.cpp
index bb9d451196263cfe22ba2ce3fb1559ad1fd7b345..0cc38c1ef3b665e2a4f1cca14d89902174d3fc45 100644
--- a/src/Classic/AbsBeamline/FlexibleCollimator.cpp
+++ b/src/Classic/AbsBeamline/FlexibleCollimator.cpp
@@ -172,7 +172,7 @@ void FlexibleCollimator::goOnline(const double&) {
void FlexibleCollimator::print() {
if (RefPartBunch_m == nullptr) {
if (!informed_m) {
- std::string errormsg = Fieldmap::typeset_msg("BUNCH SIZE NOT SET", "warning");
+ std::string errormsg = _Fieldmap::typeset_msg("BUNCH SIZE NOT SET", "warning");
ERRORMSG(errormsg << endl);
if (Ippl::myNode() == 0) {
std::ofstream omsg("errormsg.txt", std::ios_base::app);
diff --git a/src/Classic/AbsBeamline/Multipole.h b/src/Classic/AbsBeamline/Multipole.h
index 4fe440f728a17797567f3c48d0ce74e75142023f..c1a2b86a121dc9b21ca25cab054653d9a8da96aa 100644
--- a/src/Classic/AbsBeamline/Multipole.h
+++ b/src/Classic/AbsBeamline/Multipole.h
@@ -22,10 +22,10 @@
#include "AbsBeamline/Component.h"
#include "BeamlineGeometry/StraightGeometry.h"
#include "Fields/BMultipoleField.h"
+#include "Fields/Definitions.h"
template <class T, unsigned Dim>
class PartBunchBase;
-class Fieldmap;
// Class Multipole
// ------------------------------------------------------------------------
diff --git a/src/Classic/AbsBeamline/RBend3D.cpp b/src/Classic/AbsBeamline/RBend3D.cpp
index 663af4682a6b6f485e4e921d0ee2ce065b17841c..afea627b06f45b6e1b7e826e47b76b44d4141f9b 100644
--- a/src/Classic/AbsBeamline/RBend3D.cpp
+++ b/src/Classic/AbsBeamline/RBend3D.cpp
@@ -95,7 +95,7 @@ void RBend3D::initialise(PartBunchBase<double, 3> *bunch, double &startField, do
RefPartBunch_m = bunch;
- fieldmap_m = Fieldmap::getFieldmap(fileName_m, fast_m);
+ fieldmap_m = _Fieldmap::getFieldmap(fileName_m, fast_m);
if(fieldmap_m != nullptr) {
msg << level2 << getName() << " using file ";
fieldmap_m->getInfo(&msg);
@@ -189,12 +189,12 @@ void RBend3D::finalise()
{}
void RBend3D::goOnline(const double &) {
- Fieldmap::readMap(fileName_m);
+ _Fieldmap::readMap(fileName_m);
online_m = true;
}
void RBend3D::goOffline() {
- Fieldmap::freeMap(fileName_m);
+ _Fieldmap::freeMap(fileName_m);
online_m = false;
}
diff --git a/src/Classic/AbsBeamline/RBend3D.h b/src/Classic/AbsBeamline/RBend3D.h
index ef1904dcbb487d6cbea419bc4b054bf5291724f3..ba0003eae00a06775f76984ec4cdbfadbd47b8a2 100644
--- a/src/Classic/AbsBeamline/RBend3D.h
+++ b/src/Classic/AbsBeamline/RBend3D.h
@@ -24,10 +24,10 @@
#include "AbsBeamline/BendBase.h"
#include "BeamlineGeometry/StraightGeometry.h"
#include "Fields/BMultipoleField.h"
+#include "Fields/Definitions.h"
template <class T, unsigned Dim>
class PartBunchBase;
-class Fieldmap;
class MeshData;
// Class RBend3D
@@ -109,4 +109,4 @@ double RBend3D::getExitAngle() const {
return getBendAngle() - getEntranceAngle();
}
-#endif // CLASSIC_RBend3D_HH
+#endif // CLASSIC_RBend3D_HH
\ No newline at end of file
diff --git a/src/Classic/AbsBeamline/RFCavity.cpp b/src/Classic/AbsBeamline/RFCavity.cpp
index 7db8e49819c9eaee96db88b83886f0c4e53f6905..da8249adcf335ab18466de14b0f5816eb898ff7f 100644
--- a/src/Classic/AbsBeamline/RFCavity.cpp
+++ b/src/Classic/AbsBeamline/RFCavity.cpp
@@ -178,7 +178,7 @@ void RFCavity::initialise(PartBunchBase<double, 3>* bunch, double& startField, d
std::stringstream errormsg;
RefPartBunch_m = bunch;
- fieldmap_m = Fieldmap::getFieldmap(filename_m, fast_m);
+ fieldmap_m = _Fieldmap::getFieldmap(filename_m, fast_m);
fieldmap_m->getFieldDimensions(startField_m, endField);
if (endField <= startField_m) {
throw GeneralClassicException("RFCavity::initialise",
@@ -191,7 +191,7 @@ void RFCavity::initialise(PartBunchBase<double, 3>* bunch, double& startField, d
errormsg << "FREQUENCY IN INPUT FILE DIFFERENT THAN IN FIELD MAP '" << filename_m << "';\n"
<< frequency_m / Physics::two_pi * Units::Hz2MHz << " MHz <> "
<< fieldmap_m->getFrequency() / Physics::two_pi * Units::Hz2MHz << " MHz; TAKE ON THE LATTER";
- std::string errormsg_str = Fieldmap::typeset_msg(errormsg.str(), "warning");
+ std::string errormsg_str = _Fieldmap::typeset_msg(errormsg.str(), "warning");
ERRORMSG(errormsg_str << "\n" << endl);
if (Ippl::myNode() == 0) {
std::ofstream omsg("errormsg.txt", std::ios_base::app);
@@ -252,13 +252,13 @@ bool RFCavity::bends() const {
}
void RFCavity::goOnline(const double&) {
- Fieldmap::readMap(filename_m);
+ _Fieldmap::readMap(filename_m);
online_m = true;
}
void RFCavity::goOffline() {
- Fieldmap::freeMap(filename_m);
+ _Fieldmap::freeMap(filename_m);
online_m = false;
}
diff --git a/src/Classic/AbsBeamline/RFCavity.h b/src/Classic/AbsBeamline/RFCavity.h
index d082ab5ee9706a6bd8fba7c570d6865b183ef9ad..30f1b408c25f577d70f602ecd5d31736b1b96a61 100644
--- a/src/Classic/AbsBeamline/RFCavity.h
+++ b/src/Classic/AbsBeamline/RFCavity.h
@@ -21,14 +21,13 @@
#include "AbsBeamline/Component.h"
#include "Algorithms/AbstractTimeDependence.h"
#include "Physics/Physics.h"
+#include "Fields/Definitions.h"
#include <boost/bimap.hpp>
#include <cmath>
#include <string>
-class Fieldmap;
-
enum class CavityType: unsigned short {
SW,
SGSW
@@ -215,7 +214,7 @@ protected:
double designEnergy_m;
- Fieldmap* fieldmap_m;
+ Fieldmap fieldmap_m;
double startField_m; /**< starting point of field(m)*/
private:
@@ -495,4 +494,4 @@ CoordinateSystemTrafo RFCavity::getEdgeToEnd() const {
return ret;
}
-#endif // CLASSIC_RFCavity_HH
+#endif // CLASSIC_RFCavity_HH
\ No newline at end of file
diff --git a/src/Classic/AbsBeamline/Solenoid.cpp b/src/Classic/AbsBeamline/Solenoid.cpp
index c4a94ecb7b85cb71fe33df5e715d33bc770bd6b3..3da9169dc8f1da7188de79658699d200204796bf 100644
--- a/src/Classic/AbsBeamline/Solenoid.cpp
+++ b/src/Classic/AbsBeamline/Solenoid.cpp
@@ -60,7 +60,7 @@ Solenoid::Solenoid(const std::string &name):
Solenoid::~Solenoid() {
- // Fieldmap::deleteFieldmap(filename_m);
+ // _Fieldmap::deleteFieldmap(filename_m);
}
@@ -121,7 +121,7 @@ void Solenoid::initialise(PartBunchBase<double, 3> *bunch, double &startField, d
RefPartBunch_m = bunch;
- myFieldmap_m = Fieldmap::getFieldmap(filename_m, fast_m);
+ myFieldmap_m = _Fieldmap::getFieldmap(filename_m, fast_m);
if(myFieldmap_m != nullptr) {
msg << level2 << getName() << " using file ";
@@ -147,12 +147,12 @@ bool Solenoid::bends() const {
void Solenoid::goOnline(const double &) {
- Fieldmap::readMap(filename_m);
+ _Fieldmap::readMap(filename_m);
online_m = true;
}
void Solenoid::goOffline() {
- Fieldmap::freeMap(filename_m);
+ _Fieldmap::freeMap(filename_m);
online_m = false;
}
diff --git a/src/Classic/AbsBeamline/Solenoid.h b/src/Classic/AbsBeamline/Solenoid.h
index e0a72a6332eda60da1f3904402de16e9d21d1827..6281ac33ce77276320cb44c5744366a71c2782e8 100644
--- a/src/Classic/AbsBeamline/Solenoid.h
+++ b/src/Classic/AbsBeamline/Solenoid.h
@@ -22,10 +22,10 @@
// ------------------------------------------------------------------------
#include "AbsBeamline/Component.h"
+#include "Fields/Definitions.h"
template <class T, unsigned Dim>
class PartBunchBase;
-class Fieldmap;
// Class Solenoid
// ------------------------------------------------------------------------
@@ -91,7 +91,7 @@ private:
// std::string name; /**< The name of the object*/
std::string filename_m; /**< The name of the inputfile*/
- Fieldmap *myFieldmap_m;
+ Fieldmap myFieldmap_m;
double scale_m; /**< scale multiplier*/
double scaleError_m; /**< scale multiplier error*/
@@ -121,4 +121,4 @@ CoordinateSystemTrafo Solenoid::getEdgeToEnd() const
return ret;
}
-#endif // CLASSIC_Solenoid_HH
\ No newline at end of file
+#endif // CLASSIC_Solenoid_HH
diff --git a/src/Classic/AbsBeamline/TravelingWave.cpp b/src/Classic/AbsBeamline/TravelingWave.cpp
index 0f3ba3307a3aeab7eeb9e97e049e25f394a1ece6..ee58fac91f3d93cf55db55f92792180117a760d1 100644
--- a/src/Classic/AbsBeamline/TravelingWave.cpp
+++ b/src/Classic/AbsBeamline/TravelingWave.cpp
@@ -237,12 +237,12 @@ bool TravelingWave::bends() const {
}
void TravelingWave::goOnline(const double&) {
- Fieldmap::readMap(filename_m);
+ _Fieldmap::readMap(filename_m);
online_m = true;
}
void TravelingWave::goOffline() {
- Fieldmap::freeMap(filename_m);
+ _Fieldmap::freeMap(filename_m);
}
void TravelingWave::getDimensions(double& zBegin, double& zEnd) const {
diff --git a/src/Classic/AbsBeamline/TravelingWave.h b/src/Classic/AbsBeamline/TravelingWave.h
index 4e68b69c88269abbaf0d6221e5a60a0d14a1a1ee..a3096afcec8cb735eb730d5f318b7cd0f6d91d34 100644
--- a/src/Classic/AbsBeamline/TravelingWave.h
+++ b/src/Classic/AbsBeamline/TravelingWave.h
@@ -20,11 +20,10 @@
#include "AbsBeamline/RFCavity.h"
#include "Physics/Physics.h"
+#include "Fields/Definitions.h"
#include <cmath>
-class Fieldmap;
-
class TravelingWave: public RFCavity {
public:
@@ -220,4 +219,4 @@ CoordinateSystemTrafo TravelingWave::getEdgeToEnd() const {
return ret;
}
-#endif // CLASSIC_TravelingWave_HH
+#endif // CLASSIC_TravelingWave_HH
\ No newline at end of file
diff --git a/src/Classic/AbsBeamline/VariableRFCavity.h b/src/Classic/AbsBeamline/VariableRFCavity.h
index e9f85284b782f9a272b95633616a1ebb153c563c..12753d0a699d244cbed5043d7e7c9d9a75e18b2d 100644
--- a/src/Classic/AbsBeamline/VariableRFCavity.h
+++ b/src/Classic/AbsBeamline/VariableRFCavity.h
@@ -32,8 +32,8 @@
#include "Fields/EMField.h"
#include "BeamlineGeometry/StraightGeometry.h"
#include "AbsBeamline/Component.h"
+#include "Fields/Definitions.h"
-class Fieldmap;
/** @class VariableRFCavity
*
@@ -261,4 +261,4 @@ void VariableRFCavity::setWidth(double fullWidth) {
-#endif // CLASSIC_VirtualRFCavity_HH
+#endif // CLASSIC_VirtualRFCavity_HH
\ No newline at end of file
diff --git a/src/Classic/AbsBeamline/VariableRFCavityFringeField.h b/src/Classic/AbsBeamline/VariableRFCavityFringeField.h
index 9d2ceb29f67b98f8c8b2b060ceff0214688ceda2..ae848c0a8682172c2a57bd362c4d2cde7bb35829 100644
--- a/src/Classic/AbsBeamline/VariableRFCavityFringeField.h
+++ b/src/Classic/AbsBeamline/VariableRFCavityFringeField.h
@@ -30,8 +30,8 @@
#include <iostream>
#include "AbsBeamline/VariableRFCavity.h"
+#include "Fields/Definitions.h"
-class Fieldmap;
namespace endfieldmodel {
class EndFieldModel;
}
@@ -52,7 +52,7 @@ namespace endfieldmodel {
* VariableRFCavity.
*
* Set/get methods use metres; but internally we store as mm (for tracking)
- *
+ *
* Field units are kG and GV/mm
*/
class VariableRFCavityFringeField : public VariableRFCavity {
@@ -66,7 +66,7 @@ class VariableRFCavityFringeField : public VariableRFCavity {
/** Assignment operator; performs deepcopy on time-dependence models*/
VariableRFCavityFringeField& operator=(const VariableRFCavityFringeField &);
/** Destructor does nothing
- *
+ *
* The shared_ptrs will self-destruct when reference count goes to 0
*/
virtual ~VariableRFCavityFringeField();
@@ -81,7 +81,7 @@ class VariableRFCavityFringeField : public VariableRFCavity {
/** Inheritable deepcopy method */
virtual ElementBase* clone() const override;
- /** Calculate the field at the position of the i^th particle
+ /** Calculate the field at the position of the i^th particle
*
* @param i indexes the particle whose field we need
* @param t the time at which the field is calculated
@@ -126,7 +126,7 @@ class VariableRFCavityFringeField : public VariableRFCavity {
(std::shared_ptr<endfieldmodel::EndFieldModel> endField);
/** Get the endFieldModel
- *
+ *
* @returns the endFieldModel; VariableRFCavityFringe retains ownership of
* the memory allocated to the endFieldModel.
*/
@@ -134,7 +134,7 @@ class VariableRFCavityFringeField : public VariableRFCavity {
getEndField() const;
/** Initialise ready for tracking
- *
+ *
* Does any setup on VirtualRFCavity and sets field expansion coefficients
*/
virtual void initialise(PartBunchBase<double, 3> *bunch,
@@ -207,4 +207,4 @@ std::vector<std::vector<double> >
return h_m;
}
-#endif // #ifdef CLASSIC_VirtualRFCavityFringeField_HH
+#endif // #ifdef CLASSIC_VirtualRFCavityFringeField_HH
\ No newline at end of file
diff --git a/src/Classic/Fields/Astra1DDynamic.cpp b/src/Classic/Fields/Astra1DDynamic.cpp
index 607995e96ed17dae32becf6f31ad310d42e91bb6..61690ad841ca25f18a7ad4a0d41603ae721546e1 100644
--- a/src/Classic/Fields/Astra1DDynamic.cpp
+++ b/src/Classic/Fields/Astra1DDynamic.cpp
@@ -13,8 +13,8 @@
#include <ios>
-Astra1DDynamic::Astra1DDynamic(std::string aFilename):
- Fieldmap(aFilename),
+_Astra1DDynamic::_Astra1DDynamic(const std::string& filename):
+ _Fieldmap(filename),
FourCoefs_m(nullptr) {
std::ifstream file;
@@ -41,7 +41,7 @@ Astra1DDynamic::Astra1DDynamic(std::string aFilename):
tmpString = Util::toUpper(tmpString);
if (tmpString != "TRUE" &&
tmpString != "FALSE")
- throw GeneralClassicException("Astra1DDynamic::Astra1DDynamic",
+ throw GeneralClassicException("_Astra1DDynamic::_Astra1DDynamic",
"The third string on the first line of 1D field "
"maps has to be either TRUE or FALSE");
@@ -69,7 +69,7 @@ Astra1DDynamic::Astra1DDynamic(std::string aFilename):
if (!parsing_passed && !file.eof()) {
disableFieldmapWarning();
zend_m = zbegin_m - 1e-3;
- throw GeneralClassicException("Astra1DDynamic::Astra1DDynamic",
+ throw GeneralClassicException("_Astra1DDynamic::_Astra1DDynamic",
"An error occured when reading the fieldmap '" + Filename_m + "'");
} else {
// conversion from MHz to Hz and from frequency to angular frequency
@@ -85,11 +85,16 @@ Astra1DDynamic::Astra1DDynamic(std::string aFilename):
}
}
-Astra1DDynamic::~Astra1DDynamic() {
+_Astra1DDynamic::~_Astra1DDynamic() {
freeMap();
}
-void Astra1DDynamic::readMap() {
+Astra1DDynamic _Astra1DDynamic::create(const std::string& filename)
+{
+ return Astra1DDynamic(new _Astra1DDynamic(filename));
+}
+
+void _Astra1DDynamic::readMap() {
if (FourCoefs_m == nullptr) {
// declare variables and allocate memory
std::ifstream in;
@@ -173,16 +178,14 @@ void Astra1DDynamic::readMap() {
}
}
-void Astra1DDynamic::freeMap() {
+void _Astra1DDynamic::freeMap() {
if (FourCoefs_m != nullptr) {
delete[] FourCoefs_m;
FourCoefs_m = nullptr;
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info") << endl);
}
}
-bool Astra1DDynamic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const {
+bool _Astra1DDynamic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const {
// do fourier interpolation in z-direction
const double RR2 = R(0) * R(0) + R(1) * R(1);
@@ -223,7 +226,7 @@ bool Astra1DDynamic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &
return false;
}
-bool Astra1DDynamic::getFieldDerivative(const Vector_t &R, Vector_t &E, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
+bool _Astra1DDynamic::getFieldDerivative(const Vector_t &R, Vector_t &E, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
const double kz = Physics::two_pi * (R(2) - zbegin_m) / length_m + Physics::pi;
double ezp = 0.0;
@@ -236,29 +239,29 @@ bool Astra1DDynamic::getFieldDerivative(const Vector_t &R, Vector_t &E, Vector_t
return false;
}
-void Astra1DDynamic::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _Astra1DDynamic::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zbegin_m;
zEnd = zend_m;
}
-void Astra1DDynamic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
+void _Astra1DDynamic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
-void Astra1DDynamic::swap()
+void _Astra1DDynamic::swap()
{ }
-void Astra1DDynamic::getInfo(Inform *msg) {
+void _Astra1DDynamic::getInfo(Inform *msg) {
(*msg) << Filename_m << " (1D dynamic); zini= " << zbegin_m << " m; zfinal= " << zend_m << " m;" << endl;
}
-double Astra1DDynamic::getFrequency() const {
+double _Astra1DDynamic::getFrequency() const {
return frequency_m;
}
-void Astra1DDynamic::setFrequency(double freq) {
+void _Astra1DDynamic::setFrequency(double freq) {
frequency_m = freq;
}
-void Astra1DDynamic::getOnaxisEz(std::vector<std::pair<double, double> > & F) {
+void _Astra1DDynamic::getOnaxisEz(std::vector<std::pair<double, double> > & F) {
double Ez_max = 0.0;
double tmpDouble;
int tmpInt;
diff --git a/src/Classic/Fields/Astra1DDynamic.h b/src/Classic/Fields/Astra1DDynamic.h
index 89d661a3a1f6a7e95ab42546d7e3b844f7a86077..583a40628e8a7a8317d0774f1ec07e53a6a41923 100644
--- a/src/Classic/Fields/Astra1DDynamic.h
+++ b/src/Classic/Fields/Astra1DDynamic.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class Astra1DDynamic: public Fieldmap {
+class _Astra1DDynamic: public _Fieldmap {
public:
+ virtual ~_Astra1DDynamic();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual bool getFieldDerivative(const Vector_t &R, Vector_t &E, Vector_t &B, const DiffDirection &dir) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
@@ -18,8 +20,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- Astra1DDynamic(std::string aFilename);
- ~Astra1DDynamic();
+ _Astra1DDynamic(const std::string& filename);
+
+ static Astra1DDynamic create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -36,12 +39,14 @@ private:
int accuracy_m;
int num_gridpz_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool Astra1DDynamic::isInside(const Vector_t &r) const
+inline bool _Astra1DDynamic::isInside(const Vector_t &r) const
{
return r(2) >= zbegin_m && r(2) < zend_m;
}
-#endif
+using Astra1DDynamic = std::shared_ptr<_Astra1DDynamic>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/Astra1DDynamic_fast.cpp b/src/Classic/Fields/Astra1DDynamic_fast.cpp
index ac32f8ac3d16fae2023128f6ea8a537f83d861eb..32c0c686b26f261ea29ff34493672129126daffc 100644
--- a/src/Classic/Fields/Astra1DDynamic_fast.cpp
+++ b/src/Classic/Fields/Astra1DDynamic_fast.cpp
@@ -1,5 +1,5 @@
//
-// Class Astra1DDynamic_fast
+// Class _Astra1DDynamic_fast
//
// This class provides a reader for Astra style field maps. It pre-computes the field
// on a lattice to increase the performance during simulation.
@@ -29,8 +29,8 @@
#include <fstream>
#include <ios>
-Astra1DDynamic_fast::Astra1DDynamic_fast(std::string aFilename):
- Astra1D_fast(aFilename)
+_Astra1DDynamic_fast::_Astra1DDynamic_fast(const std::string& filename):
+ _Astra1D_fast(filename)
{
numHeaderLines_m = 3;
@@ -55,7 +55,7 @@ Astra1DDynamic_fast::Astra1DDynamic_fast(std::string aFilename):
if(!parsing_passed) {
disableFieldmapWarning();
zend_m = zbegin_m - 1e-3;
- throw GeneralClassicException("Astra1DDynamic_fast::Astra1DDynamic_fast",
+ throw GeneralClassicException("_Astra1DDynamic_fast::_Astra1DDynamic_fast",
"An error occured when reading the fieldmap '" + Filename_m + "'");
}
@@ -67,11 +67,16 @@ Astra1DDynamic_fast::Astra1DDynamic_fast(std::string aFilename):
length_m = 2.0 * num_gridpz_m * hz_m;
}
-Astra1DDynamic_fast::~Astra1DDynamic_fast() {
+_Astra1DDynamic_fast::~_Astra1DDynamic_fast() {
freeMap();
}
-void Astra1DDynamic_fast::readMap() {
+Astra1DDynamic_fast _Astra1DDynamic_fast::create(const std::string& filename)
+{
+ return Astra1DDynamic_fast(new _Astra1DDynamic_fast(filename));
+}
+
+void _Astra1DDynamic_fast::readMap() {
if(onAxisField_m == nullptr) {
std::ifstream file(Filename_m.c_str());
@@ -101,7 +106,7 @@ void Astra1DDynamic_fast::readMap() {
}
}
-bool Astra1DDynamic_fast::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const {
+bool _Astra1DDynamic_fast::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const {
// do fourier interpolation in z-direction
const double RR2 = R(0) * R(0) + R(1) * R(1);
@@ -112,7 +117,7 @@ bool Astra1DDynamic_fast::getFieldstrength(const Vector_t &R, Vector_t &E, Vecto
ezpp = gsl_spline_eval(onAxisInterpolants_m[2], R(2) - zbegin_m, onAxisAccel_m[2]);
ezppp = gsl_spline_eval(onAxisInterpolants_m[3], R(2) - zbegin_m, onAxisAccel_m[3]);
} catch (OpalException const& e) {
- throw OpalException("Astra1DDynamic_fast::getFieldstrength",
+ throw OpalException("_Astra1DDynamic_fast::getFieldstrength",
"The requested interpolation point, " + std::to_string(R(2)) + " is out of range");
}
// expand the field off-axis
@@ -131,7 +136,7 @@ bool Astra1DDynamic_fast::getFieldstrength(const Vector_t &R, Vector_t &E, Vecto
return false;
}
-bool Astra1DDynamic_fast::getFieldDerivative(const Vector_t &R, Vector_t &E, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
+bool _Astra1DDynamic_fast::getFieldDerivative(const Vector_t &R, Vector_t &E, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
double ezp = gsl_spline_eval(onAxisInterpolants_m[1], R(2) - zbegin_m, onAxisAccel_m[1]);
E(2) += ezp;
@@ -139,29 +144,29 @@ bool Astra1DDynamic_fast::getFieldDerivative(const Vector_t &R, Vector_t &E, Vec
return false;
}
-void Astra1DDynamic_fast::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _Astra1DDynamic_fast::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zbegin_m;
zEnd = zend_m;
}
-void Astra1DDynamic_fast::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
+void _Astra1DDynamic_fast::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
-void Astra1DDynamic_fast::swap()
+void _Astra1DDynamic_fast::swap()
{ }
-void Astra1DDynamic_fast::getInfo(Inform *msg) {
+void _Astra1DDynamic_fast::getInfo(Inform *msg) {
(*msg) << Filename_m << " (1D dynamic); zini= " << zbegin_m << " m; zfinal= " << zend_m << " m;" << endl;
}
-double Astra1DDynamic_fast::getFrequency() const {
+double _Astra1DDynamic_fast::getFrequency() const {
return frequency_m;
}
-void Astra1DDynamic_fast::setFrequency(double freq) {
+void _Astra1DDynamic_fast::setFrequency(double freq) {
frequency_m = freq;
}
-void Astra1DDynamic_fast::getOnaxisEz(std::vector<std::pair<double, double> > & F) {
+void _Astra1DDynamic_fast::getOnaxisEz(std::vector<std::pair<double, double> > & F) {
F.resize(num_gridpz_m);
if(onAxisField_m == nullptr) {
double Ez_max = 0.0;
@@ -195,7 +200,7 @@ void Astra1DDynamic_fast::getOnaxisEz(std::vector<std::pair<double, double> > &
}
}
-bool Astra1DDynamic_fast::readFileHeader(std::ifstream &file) {
+bool _Astra1DDynamic_fast::readFileHeader(std::ifstream &file) {
std::string tmpString;
int tmpInt;
bool passed = true;
@@ -208,7 +213,7 @@ bool Astra1DDynamic_fast::readFileHeader(std::ifstream &file) {
tmpString = Util::toUpper(tmpString);
if (tmpString != "TRUE" &&
tmpString != "FALSE")
- throw GeneralClassicException("Astra1DDynamic_fast::readFileHeader",
+ throw GeneralClassicException("_Astra1DDynamic_fast::readFileHeader",
"The third string on the first line of 1D field "
"maps has to be either TRUE or FALSE");
@@ -220,7 +225,7 @@ bool Astra1DDynamic_fast::readFileHeader(std::ifstream &file) {
return passed;
}
-int Astra1DDynamic_fast::stripFileHeader(std::ifstream &file) {
+int _Astra1DDynamic_fast::stripFileHeader(std::ifstream &file) {
std::string tmpString;
double tmpDouble;
int accuracy;
@@ -234,4 +239,4 @@ int Astra1DDynamic_fast::stripFileHeader(std::ifstream &file) {
interpretLine<double>(file, tmpDouble);
return accuracy;
-}
+}
\ No newline at end of file
diff --git a/src/Classic/Fields/Astra1DDynamic_fast.h b/src/Classic/Fields/Astra1DDynamic_fast.h
index c00fed089cc792cbba4516a021728273442a6b71..90c37b920362057a4376a1e682df4d558aac5aa4 100644
--- a/src/Classic/Fields/Astra1DDynamic_fast.h
+++ b/src/Classic/Fields/Astra1DDynamic_fast.h
@@ -24,9 +24,11 @@
#include "Fields/Astra1D_fast.h"
-class Astra1DDynamic_fast: public Astra1D_fast {
+class _Astra1DDynamic_fast: public _Astra1D_fast {
public:
+ virtual ~_Astra1DDynamic_fast();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual bool getFieldDerivative(const Vector_t &R, Vector_t &E, Vector_t &B, const DiffDirection &dir) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
@@ -38,8 +40,9 @@ public:
virtual void getOnaxisEz(std::vector<std::pair<double, double> > & F);
private:
- Astra1DDynamic_fast(std::string aFilename);
- virtual ~Astra1DDynamic_fast();
+ _Astra1DDynamic_fast(const std::string& filename);
+
+ static Astra1DDynamic_fast create(const std::string& filename);
virtual void readMap();
@@ -49,7 +52,8 @@ private:
double frequency_m;
double xlrep_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
+using Astra1DDynamic_fast = std::shared_ptr<_Astra1DDynamic_fast>;
#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/Astra1DElectroStatic.cpp b/src/Classic/Fields/Astra1DElectroStatic.cpp
index e15a758459a1249e835cc20248aa23fd70fcc417..1b2c1f761b9e5115ae5305e08b44c210a04a9f53 100644
--- a/src/Classic/Fields/Astra1DElectroStatic.cpp
+++ b/src/Classic/Fields/Astra1DElectroStatic.cpp
@@ -12,8 +12,8 @@
#include <fstream>
#include <ios>
-Astra1DElectroStatic::Astra1DElectroStatic(std::string aFilename)
- : Fieldmap(aFilename),
+_Astra1DElectroStatic::_Astra1DElectroStatic(const std::string& filename)
+ : _Fieldmap(filename),
FourCoefs_m(nullptr) {
std::ifstream file;
@@ -38,7 +38,7 @@ Astra1DElectroStatic::Astra1DElectroStatic(std::string aFilename)
tmpString = Util::toUpper(tmpString);
if (tmpString != "TRUE" &&
tmpString != "FALSE")
- throw GeneralClassicException("Astra1DElectroStatic::Astra1DElectroStatic",
+ throw GeneralClassicException("_Astra1DElectroStatic::_Astra1DElectroStatic",
"The third string on the first line of 1D field "
"maps has to be either TRUE or FALSE");
@@ -64,7 +64,7 @@ Astra1DElectroStatic::Astra1DElectroStatic(std::string aFilename)
if (!parsing_passed && !file.eof()) {
disableFieldmapWarning();
zend_m = zbegin_m - 1e-3;
- throw GeneralClassicException("Astra1DElectroStatic::Astra1DElectroStatic",
+ throw GeneralClassicException("_Astra1DElectroStatic::_Astra1DElectroStatic",
"An error occured when reading the fieldmap '" + Filename_m + "'");
}
length_m = 2.0 * num_gridpz_m * (zend_m - zbegin_m) / (num_gridpz_m - 1);
@@ -76,11 +76,16 @@ Astra1DElectroStatic::Astra1DElectroStatic(std::string aFilename)
}
}
-Astra1DElectroStatic::~Astra1DElectroStatic() {
+_Astra1DElectroStatic::~_Astra1DElectroStatic() {
freeMap();
}
-void Astra1DElectroStatic::readMap() {
+Astra1DElectroStatic _Astra1DElectroStatic::create(const std::string& filename)
+{
+ return Astra1DElectroStatic(new _Astra1DElectroStatic(filename));
+}
+
+void _Astra1DElectroStatic::readMap() {
if (FourCoefs_m == nullptr) {
// declare variables and allocate memory
@@ -167,17 +172,15 @@ void Astra1DElectroStatic::readMap() {
}
}
-void Astra1DElectroStatic::freeMap() {
+void _Astra1DElectroStatic::freeMap() {
if (FourCoefs_m != nullptr) {
delete[] FourCoefs_m;
FourCoefs_m = nullptr;
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info") << endl);
}
}
-bool Astra1DElectroStatic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &/*B*/) const {
+bool _Astra1DElectroStatic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &/*B*/) const {
// do fourier interpolation in z-direction
const double RR2 = R(0) * R(0) + R(1) * R(1);
@@ -212,27 +215,27 @@ bool Astra1DElectroStatic::getFieldstrength(const Vector_t &R, Vector_t &E, Vect
return false;
}
-bool Astra1DElectroStatic::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
+bool _Astra1DElectroStatic::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
return false;
}
-void Astra1DElectroStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _Astra1DElectroStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zbegin_m;
zEnd = zend_m;
}
-void Astra1DElectroStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
+void _Astra1DElectroStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
-void Astra1DElectroStatic::swap()
+void _Astra1DElectroStatic::swap()
{ }
-void Astra1DElectroStatic::getInfo(Inform *msg) {
+void _Astra1DElectroStatic::getInfo(Inform *msg) {
(*msg) << Filename_m << " (1D electrostatic); zini= " << zbegin_m << " m; zfinal= " << zend_m << " m;" << endl;
}
-double Astra1DElectroStatic::getFrequency() const {
+double _Astra1DElectroStatic::getFrequency() const {
return 0.0;
}
-void Astra1DElectroStatic::setFrequency(double /*freq*/)
+void _Astra1DElectroStatic::setFrequency(double /*freq*/)
{ }
diff --git a/src/Classic/Fields/Astra1DElectroStatic.h b/src/Classic/Fields/Astra1DElectroStatic.h
index 1c1b8c5274ccd1a2f17d6becdc455976786029c3..eddfa40b25d6397b9bf969e8fcf226cd68c77bf9 100644
--- a/src/Classic/Fields/Astra1DElectroStatic.h
+++ b/src/Classic/Fields/Astra1DElectroStatic.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class Astra1DElectroStatic: public Fieldmap {
+class _Astra1DElectroStatic: public _Fieldmap {
public:
+ virtual ~_Astra1DElectroStatic();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
virtual void getFieldDimensions(double &xIni, double &xFinal, double &yIni, double &yFinal, double &zIni, double &zFinal) const;
@@ -17,8 +19,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- Astra1DElectroStatic(std::string aFilename);
- ~Astra1DElectroStatic();
+ _Astra1DElectroStatic(const std::string& filename);
+
+ static Astra1DElectroStatic create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -32,12 +35,14 @@ private:
int accuracy_m;
int num_gridpz_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool Astra1DElectroStatic::isInside(const Vector_t &r) const
+inline bool _Astra1DElectroStatic::isInside(const Vector_t &r) const
{
return r(2) >= zbegin_m && r(2) < zend_m;
}
+using Astra1DElectroStatic = std::shared_ptr<_Astra1DElectroStatic>;
+
#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/Astra1DElectroStatic_fast.cpp b/src/Classic/Fields/Astra1DElectroStatic_fast.cpp
index 60e95f0e6ff9b5da613457ea29ae50684bbdb8a2..0fc642cb3a59e2e581ecb186b40301b4d15fc323 100644
--- a/src/Classic/Fields/Astra1DElectroStatic_fast.cpp
+++ b/src/Classic/Fields/Astra1DElectroStatic_fast.cpp
@@ -7,8 +7,8 @@
#include <fstream>
#include <ios>
-Astra1DElectroStatic_fast::Astra1DElectroStatic_fast(std::string aFilename):
- Astra1D_fast(aFilename) {
+_Astra1DElectroStatic_fast::_Astra1DElectroStatic_fast(const std::string& filename):
+ _Astra1D_fast(filename) {
numHeaderLines_m = 2;
onAxisField_m = nullptr;
@@ -30,18 +30,23 @@ Astra1DElectroStatic_fast::Astra1DElectroStatic_fast(std::string aFilename):
if(!parsing_passed && !file.eof()) {
disableFieldmapWarning();
zend_m = zbegin_m - 1e-3;
- throw GeneralClassicException("Astra1DElectroStatic_fast::Astra1DElectroStatic_fast",
+ throw GeneralClassicException("_Astra1DElectroStatic_fast::_Astra1DElectroStatic_fast",
"An error occured when reading the fieldmap '" + Filename_m + "'");
}
hz_m = (zend_m - zbegin_m) / (num_gridpz_m - 1);
length_m = 2.0 * num_gridpz_m * hz_m;
}
-Astra1DElectroStatic_fast::~Astra1DElectroStatic_fast() {
+_Astra1DElectroStatic_fast::~_Astra1DElectroStatic_fast() {
freeMap();
}
-void Astra1DElectroStatic_fast::readMap() {
+Astra1DElectroStatic_fast _Astra1DElectroStatic_fast::create(const std::string& filename)
+{
+ return Astra1DElectroStatic_fast(new _Astra1DElectroStatic_fast(filename));
+}
+
+void _Astra1DElectroStatic_fast::readMap() {
if(onAxisField_m == nullptr) {
// declare variables and allocate memory
@@ -73,7 +78,7 @@ void Astra1DElectroStatic_fast::readMap() {
}
}
-bool Astra1DElectroStatic_fast::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &/*B*/) const {
+bool _Astra1DElectroStatic_fast::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &/*B*/) const {
// do fourier interpolation in z-direction
const double RR2 = R(0) * R(0) + R(1) * R(1);
@@ -91,31 +96,31 @@ bool Astra1DElectroStatic_fast::getFieldstrength(const Vector_t &R, Vector_t &E,
return false;
}
-bool Astra1DElectroStatic_fast::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
+bool _Astra1DElectroStatic_fast::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
return false;
}
-void Astra1DElectroStatic_fast::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _Astra1DElectroStatic_fast::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zbegin_m;
zEnd = zend_m;
}
-void Astra1DElectroStatic_fast::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
+void _Astra1DElectroStatic_fast::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
-void Astra1DElectroStatic_fast::swap()
+void _Astra1DElectroStatic_fast::swap()
{ }
-void Astra1DElectroStatic_fast::getInfo(Inform *msg) {
+void _Astra1DElectroStatic_fast::getInfo(Inform *msg) {
(*msg) << Filename_m << " (1D electrostatic); zini= " << zbegin_m << " m; zfinal= " << zend_m << " m;" << endl;
}
-double Astra1DElectroStatic_fast::getFrequency() const {
+double _Astra1DElectroStatic_fast::getFrequency() const {
return 0.0;
}
-void Astra1DElectroStatic_fast::setFrequency(double /*freq*/)
+void _Astra1DElectroStatic_fast::setFrequency(double /*freq*/)
{ }
-bool Astra1DElectroStatic_fast::readFileHeader(std::ifstream &file) {
+bool _Astra1DElectroStatic_fast::readFileHeader(std::ifstream &file) {
std::string tmpString;
int tmpInt;
@@ -138,7 +143,7 @@ bool Astra1DElectroStatic_fast::readFileHeader(std::ifstream &file) {
return passed;
}
-int Astra1DElectroStatic_fast::stripFileHeader(std::ifstream &file) {
+int _Astra1DElectroStatic_fast::stripFileHeader(std::ifstream &file) {
std::string tmpString;
int accuracy;
@@ -149,5 +154,4 @@ int Astra1DElectroStatic_fast::stripFileHeader(std::ifstream &file) {
}
return accuracy;
-}
-
+}
\ No newline at end of file
diff --git a/src/Classic/Fields/Astra1DElectroStatic_fast.h b/src/Classic/Fields/Astra1DElectroStatic_fast.h
index ae76f4677b6aec45e0ee0c243af6d0bcd0a8a667..73c42d5d7b551175f6bb60129c58cd561a8f5be4 100644
--- a/src/Classic/Fields/Astra1DElectroStatic_fast.h
+++ b/src/Classic/Fields/Astra1DElectroStatic_fast.h
@@ -3,9 +3,11 @@
#include "Fields/Astra1D_fast.h"
-class Astra1DElectroStatic_fast: public Astra1D_fast {
+class _Astra1DElectroStatic_fast: public _Astra1D_fast {
public:
+ virtual ~_Astra1DElectroStatic_fast();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
virtual void getFieldDimensions(double &xIni, double &xFinal, double &yIni, double &yFinal, double &zIni, double &zFinal) const;
@@ -16,15 +18,18 @@ public:
virtual void setFrequency(double freq);
private:
- Astra1DElectroStatic_fast(std::string aFilename);
- ~Astra1DElectroStatic_fast();
+ _Astra1DElectroStatic_fast(const std::string& filename);
+
+ static Astra1DElectroStatic_fast create(const std::string& filename);
virtual void readMap();
bool readFileHeader(std::ifstream &file);
int stripFileHeader(std::ifstream &file);
- friend class Fieldmap;
+ friend class _Fieldmap;
};
+using Astra1DElectroStatic_fast = std::shared_ptr<_Astra1DElectroStatic_fast>;
+
#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/Astra1DMagnetoStatic.cpp b/src/Classic/Fields/Astra1DMagnetoStatic.cpp
index f6071b4056ef1f608e2b194abb847b4961ce080a..e9eb7ee916de7d0fc806edf32a17343dd37f8ae8 100644
--- a/src/Classic/Fields/Astra1DMagnetoStatic.cpp
+++ b/src/Classic/Fields/Astra1DMagnetoStatic.cpp
@@ -12,8 +12,8 @@
#include <ios>
-Astra1DMagnetoStatic::Astra1DMagnetoStatic(std::string aFilename)
- : Fieldmap(aFilename),
+_Astra1DMagnetoStatic::_Astra1DMagnetoStatic(const std::string& filename)
+ : _Fieldmap(filename),
FourCoefs_m(nullptr) {
std::ifstream file;
int skippedValues = 0;
@@ -34,7 +34,7 @@ Astra1DMagnetoStatic::Astra1DMagnetoStatic(std::string aFilename)
tmpString = Util::toUpper(tmpString);
if (tmpString != "TRUE" &&
tmpString != "FALSE")
- throw GeneralClassicException("Astra1DMagnetoStatic::Astra1DMagnetoStatic",
+ throw GeneralClassicException("_Astra1DMagnetoStatic::_Astra1DMagnetoStatic",
"The third string on the first line of 1D field "
"maps has to be either TRUE or FALSE");
@@ -60,7 +60,7 @@ Astra1DMagnetoStatic::Astra1DMagnetoStatic(std::string aFilename)
if (!parsing_passed && !file.eof()) {
disableFieldmapWarning();
zend_m = zbegin_m - 1e-3;
- throw GeneralClassicException("Astra1DMagnetoStatic::Astra1DMagnetoStatic",
+ throw GeneralClassicException("_Astra1DMagnetoStatic::_Astra1DMagnetoStatic",
"An error occured when reading the fieldmap '" + Filename_m + "'");
}
length_m = 2.0 * num_gridpz_m * (zend_m - zbegin_m) / (num_gridpz_m - 1);
@@ -71,11 +71,16 @@ Astra1DMagnetoStatic::Astra1DMagnetoStatic(std::string aFilename)
}
}
-Astra1DMagnetoStatic::~Astra1DMagnetoStatic() {
+_Astra1DMagnetoStatic::~_Astra1DMagnetoStatic() {
freeMap();
}
-void Astra1DMagnetoStatic::readMap() {
+Astra1DMagnetoStatic _Astra1DMagnetoStatic::create(const std::string& filename)
+{
+ return Astra1DMagnetoStatic(new _Astra1DMagnetoStatic(filename));
+}
+
+void _Astra1DMagnetoStatic::readMap() {
if (FourCoefs_m == nullptr) {
// declare variables and allocate memory
std::ifstream in;
@@ -157,17 +162,15 @@ void Astra1DMagnetoStatic::readMap() {
}
}
-void Astra1DMagnetoStatic::freeMap() {
+void _Astra1DMagnetoStatic::freeMap() {
if (FourCoefs_m != nullptr) {
delete[] FourCoefs_m;
FourCoefs_m = nullptr;
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info") << endl);
}
}
-bool Astra1DMagnetoStatic::getFieldstrength(const Vector_t &R, Vector_t &/*E*/, Vector_t &B) const {
+bool _Astra1DMagnetoStatic::getFieldstrength(const Vector_t &R, Vector_t &/*E*/, Vector_t &B) const {
// do fourier interpolation in z-direction
const double RR2 = R(0) * R(0) + R(1) * R(1);
@@ -202,26 +205,26 @@ bool Astra1DMagnetoStatic::getFieldstrength(const Vector_t &R, Vector_t &/*E*/,
return false;
}
-bool Astra1DMagnetoStatic::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
+bool _Astra1DMagnetoStatic::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
return false;
}
-void Astra1DMagnetoStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _Astra1DMagnetoStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zbegin_m;
zEnd = zend_m;
}
-void Astra1DMagnetoStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
+void _Astra1DMagnetoStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
-void Astra1DMagnetoStatic::swap()
+void _Astra1DMagnetoStatic::swap()
{ }
-void Astra1DMagnetoStatic::getInfo(Inform *msg) {
+void _Astra1DMagnetoStatic::getInfo(Inform *msg) {
(*msg) << Filename_m << " (1D magnetostatic); zini= " << zbegin_m << " m; zfinal= " << zend_m << " m;" << endl;
}
-double Astra1DMagnetoStatic::getFrequency() const {
+double _Astra1DMagnetoStatic::getFrequency() const {
return 0.0;
}
-void Astra1DMagnetoStatic::setFrequency(double /*freq*/)
+void _Astra1DMagnetoStatic::setFrequency(double /*freq*/)
{ }
diff --git a/src/Classic/Fields/Astra1DMagnetoStatic.h b/src/Classic/Fields/Astra1DMagnetoStatic.h
index 6da6d1a80476e4cc19b7f669e909980405901481..7a7a9d41c4227a59877b0ef171af9e9ffb1b72a6 100644
--- a/src/Classic/Fields/Astra1DMagnetoStatic.h
+++ b/src/Classic/Fields/Astra1DMagnetoStatic.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class Astra1DMagnetoStatic: public Fieldmap {
+class _Astra1DMagnetoStatic: public _Fieldmap {
public:
+ virtual ~_Astra1DMagnetoStatic();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
virtual void getFieldDimensions(double &xIni, double &xFinal, double &yIni, double &yFinal, double &zIni, double &zFinal) const;
@@ -17,8 +19,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- Astra1DMagnetoStatic(std::string aFilename);
- ~Astra1DMagnetoStatic();
+ _Astra1DMagnetoStatic(const std::string& filename);
+
+ static Astra1DMagnetoStatic create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -32,12 +35,14 @@ private:
int accuracy_m;
int num_gridpz_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool Astra1DMagnetoStatic::isInside(const Vector_t &r) const
+inline bool _Astra1DMagnetoStatic::isInside(const Vector_t &r) const
{
return r(2) >= zbegin_m && r(2) < zend_m;
}
+using Astra1DMagnetoStatic = std::shared_ptr<_Astra1DMagnetoStatic>;
+
#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/Astra1DMagnetoStatic_fast.cpp b/src/Classic/Fields/Astra1DMagnetoStatic_fast.cpp
index 7a41e46d58e52e1f293ad96989dbe2abe213b325..2c076c7e58319aaebe46dadca38e22af762ccd06 100644
--- a/src/Classic/Fields/Astra1DMagnetoStatic_fast.cpp
+++ b/src/Classic/Fields/Astra1DMagnetoStatic_fast.cpp
@@ -6,8 +6,8 @@
#include <fstream>
#include <ios>
-Astra1DMagnetoStatic_fast::Astra1DMagnetoStatic_fast(std::string aFilename):
- Astra1D_fast(aFilename)
+_Astra1DMagnetoStatic_fast::_Astra1DMagnetoStatic_fast(const std::string& filename):
+ _Astra1D_fast(filename)
{
numHeaderLines_m = 2;
@@ -31,18 +31,23 @@ Astra1DMagnetoStatic_fast::Astra1DMagnetoStatic_fast(std::string aFilename):
if(!parsing_passed) {
disableFieldmapWarning();
zend_m = zbegin_m - 1e-3;
- throw GeneralClassicException("Astra1DMagnetoStatic_fast::Astra1DMagnetoStatic_fast",
+ throw GeneralClassicException("_Astra1DMagnetoStatic_fast::_Astra1DMagnetoStatic_fast",
"An error occured when reading the fieldmap '" + Filename_m + "'");
}
hz_m = (zend_m - zbegin_m) / (num_gridpz_m - 1);
length_m = 2.0 * num_gridpz_m * hz_m;
}
-Astra1DMagnetoStatic_fast::~Astra1DMagnetoStatic_fast() {
+_Astra1DMagnetoStatic_fast::~_Astra1DMagnetoStatic_fast() {
freeMap();
}
-void Astra1DMagnetoStatic_fast::readMap() {
+Astra1DMagnetoStatic_fast _Astra1DMagnetoStatic_fast::create(const std::string& filename)
+{
+ return Astra1DMagnetoStatic_fast(new _Astra1DMagnetoStatic_fast(filename));
+}
+
+void _Astra1DMagnetoStatic_fast::readMap() {
if(onAxisField_m == nullptr) {
onAxisField_m = new double[num_gridpz_m];
zvals_m = new double[num_gridpz_m];
@@ -72,7 +77,7 @@ void Astra1DMagnetoStatic_fast::readMap() {
}
}
-bool Astra1DMagnetoStatic_fast::getFieldstrength(const Vector_t &R, Vector_t &/*E*/, Vector_t &B) const {
+bool _Astra1DMagnetoStatic_fast::getFieldstrength(const Vector_t &R, Vector_t &/*E*/, Vector_t &B) const {
// do fourier interpolation in z-direction
const double RR2 = R(0) * R(0) + R(1) * R(1);
@@ -90,32 +95,32 @@ bool Astra1DMagnetoStatic_fast::getFieldstrength(const Vector_t &R, Vector_t &/*
return false;
}
-bool Astra1DMagnetoStatic_fast::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
+bool _Astra1DMagnetoStatic_fast::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
return false;
}
-void Astra1DMagnetoStatic_fast::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _Astra1DMagnetoStatic_fast::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zbegin_m;
zEnd = zend_m;
}
-void Astra1DMagnetoStatic_fast::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
+void _Astra1DMagnetoStatic_fast::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
-void Astra1DMagnetoStatic_fast::swap()
+void _Astra1DMagnetoStatic_fast::swap()
{ }
-void Astra1DMagnetoStatic_fast::getInfo(Inform *msg) {
+void _Astra1DMagnetoStatic_fast::getInfo(Inform *msg) {
(*msg) << Filename_m << " (1D magnetostatic); zini= " << zbegin_m << " m; zfinal= " << zend_m << " m;" << endl;
}
-double Astra1DMagnetoStatic_fast::getFrequency() const {
+double _Astra1DMagnetoStatic_fast::getFrequency() const {
return 0.0;
}
-void Astra1DMagnetoStatic_fast::setFrequency(double /*freq*/)
+void _Astra1DMagnetoStatic_fast::setFrequency(double /*freq*/)
{ }
-bool Astra1DMagnetoStatic_fast::readFileHeader(std::ifstream &file) {
+bool _Astra1DMagnetoStatic_fast::readFileHeader(std::ifstream &file) {
std::string tmpString;
int tmpInt;
@@ -138,7 +143,7 @@ bool Astra1DMagnetoStatic_fast::readFileHeader(std::ifstream &file) {
return passed;
}
-int Astra1DMagnetoStatic_fast::stripFileHeader(std::ifstream &file) {
+int _Astra1DMagnetoStatic_fast::stripFileHeader(std::ifstream &file) {
std::string tmpString;
int accuracy;
@@ -149,5 +154,4 @@ int Astra1DMagnetoStatic_fast::stripFileHeader(std::ifstream &file) {
}
return accuracy;
-}
-
+}
\ No newline at end of file
diff --git a/src/Classic/Fields/Astra1DMagnetoStatic_fast.h b/src/Classic/Fields/Astra1DMagnetoStatic_fast.h
index 9420b38f6364cc1dd94921e29f4e6109a66a43ff..60d1f687a26be00e929151ed3fcebed078be6668 100644
--- a/src/Classic/Fields/Astra1DMagnetoStatic_fast.h
+++ b/src/Classic/Fields/Astra1DMagnetoStatic_fast.h
@@ -2,10 +2,13 @@
#define CLASSIC_AstraFIELDMAP1DMAGNETOSTATICFAST_HH
#include "Fields/Astra1D_fast.h"
+#include "Fields/Definitions.h"
-class Astra1DMagnetoStatic_fast: public Astra1D_fast {
+class _Astra1DMagnetoStatic_fast: public _Astra1D_fast {
public:
+ virtual ~_Astra1DMagnetoStatic_fast();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
virtual void getFieldDimensions(double &xIni, double &xFinal, double &yIni, double &yFinal, double &zIni, double &zFinal) const;
@@ -16,15 +19,18 @@ public:
virtual void setFrequency(double freq);
private:
- Astra1DMagnetoStatic_fast(std::string aFilename);
- virtual ~Astra1DMagnetoStatic_fast();
+ _Astra1DMagnetoStatic_fast(const std::string& filename);
+
+ static Astra1DMagnetoStatic_fast create(const std::string& filename);
virtual void readMap();
bool readFileHeader(std::ifstream &file);
int stripFileHeader(std::ifstream &file);
- friend class Fieldmap;
+ friend class _Fieldmap;
};
+using Astra1DMagnetoStatic_fast = std::shared_ptr<_Astra1DMagnetoStatic_fast>;
+
#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/Astra1D_fast.cpp b/src/Classic/Fields/Astra1D_fast.cpp
index 3f965450829d5324d40a4f3395b1fd14f03eb3d3..4e8ba0331b53c8686abd25fa315383ce1bb65a11 100644
--- a/src/Classic/Fields/Astra1D_fast.cpp
+++ b/src/Classic/Fields/Astra1D_fast.cpp
@@ -1,3 +1,4 @@
+
#include "Fields/Astra1D_fast.h"
#include "Fields/Fieldmap.hpp"
#include "Physics/Physics.h"
@@ -6,19 +7,19 @@
#include <fstream>
#include <ios>
-Astra1D_fast::Astra1D_fast(std::string aFilename):
- Fieldmap(aFilename) {
+_Astra1D_fast::_Astra1D_fast(const std::string& filename):
+ _Fieldmap(filename) {
normalize_m = true;
}
-Astra1D_fast::~Astra1D_fast() {
+_Astra1D_fast::~_Astra1D_fast() {
freeMap();
}
-void Astra1D_fast::readMap()
+void _Astra1D_fast::readMap()
{ }
-void Astra1D_fast::freeMap() {
+void _Astra1D_fast::freeMap() {
if(onAxisField_m != nullptr) {
for(int i = 0; i < 4; ++i) {
gsl_spline_free(onAxisInterpolants_m[i]);
@@ -29,15 +30,13 @@ void Astra1D_fast::freeMap() {
onAxisField_m = nullptr;
delete[] zvals_m;
zvals_m = nullptr;
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info") << endl);
}
}
-void Astra1D_fast::getOnaxisEz(std::vector<std::pair<double, double> > & /*F*/)
+void _Astra1D_fast::getOnaxisEz(std::vector<std::pair<double, double> > & /*F*/)
{ }
-bool Astra1D_fast::determineNumSamplingPoints(std::ifstream &file) {
+bool _Astra1D_fast::determineNumSamplingPoints(std::ifstream &file) {
double tmpDouble, tmpDouble2;
unsigned int skippedValues = 0;
bool passed = interpretLine<double, double>(file, zbegin_m, tmpDouble);
@@ -58,7 +57,7 @@ bool Astra1D_fast::determineNumSamplingPoints(std::ifstream &file) {
return passed || file.eof();
}
-double Astra1D_fast::readFieldData(std::ifstream &file) {
+double _Astra1D_fast::readFieldData(std::ifstream &file) {
double tmpDouble = zbegin_m - hz_m;
double maxValue = 0;
int nsp;
@@ -82,7 +81,7 @@ double Astra1D_fast::readFieldData(std::ifstream &file) {
return maxValue;
}
-void Astra1D_fast::normalizeFieldData(double maxValue) {
+void _Astra1D_fast::normalizeFieldData(double maxValue) {
int ii = num_gridpz_m - 1;
for(int i = 0; i < num_gridpz_m; ++ i, -- ii) {
onAxisField_m[i] /= maxValue;
@@ -90,7 +89,7 @@ void Astra1D_fast::normalizeFieldData(double maxValue) {
}
}
-std::vector<double> Astra1D_fast::getEvenlyDistributedSamplingPoints() {
+std::vector<double> _Astra1D_fast::getEvenlyDistributedSamplingPoints() {
std::vector<double> zvals(num_gridpz_m, 0.0);
for(int i = 1; i < num_gridpz_m - 1; ++ i) {
@@ -101,7 +100,7 @@ std::vector<double> Astra1D_fast::getEvenlyDistributedSamplingPoints() {
return zvals;
}
-std::vector<double> Astra1D_fast::interpolateFieldData(std::vector<double> &samplingPoints) {
+std::vector<double> _Astra1D_fast::interpolateFieldData(std::vector<double> &samplingPoints) {
std::vector<double> realValues(num_gridpz_m);
onAxisInterpolants_m[0] = gsl_spline_alloc(gsl_interp_cspline, num_gridpz_m);
@@ -117,7 +116,7 @@ std::vector<double> Astra1D_fast::interpolateFieldData(std::vector<double> &samp
return realValues;
}
-std::vector<double> Astra1D_fast::computeFourierCoefficients(int accuracy,
+std::vector<double> _Astra1D_fast::computeFourierCoefficients(int accuracy,
std::vector<double> &evenFieldSampling) {
std::vector<double> fourierCoefficients(2 * accuracy - 1);
std::vector<double> RealValues(2 * num_gridpz_m, 0.0);
@@ -145,7 +144,7 @@ std::vector<double> Astra1D_fast::computeFourierCoefficients(int accuracy,
return fourierCoefficients;
}
-void Astra1D_fast::computeFieldDerivatives(std::vector<double> & fourierComponents, int accuracy) {
+void _Astra1D_fast::computeFieldDerivatives(std::vector<double> & fourierComponents, int accuracy) {
double interiorDerivative, base;
double coskzl, sinkzl, z = 0.0;
std::vector<double> zvals(num_gridpz_m);
@@ -181,5 +180,4 @@ void Astra1D_fast::computeFieldDerivatives(std::vector<double> & fourierComponen
onAxisAccel_m[i] = gsl_interp_accel_alloc();
gsl_spline_init(onAxisInterpolants_m[i], &zvals[0], &higherDerivatives[i - 1][0], num_gridpz_m);
}
-}
-
+}
\ No newline at end of file
diff --git a/src/Classic/Fields/Astra1D_fast.h b/src/Classic/Fields/Astra1D_fast.h
index 157d4037deb1c5c382cc7a6753ca2cdb3a982ff0..81eb86fccadc4f7aaf27d03f4d4eab320481eaf1 100644
--- a/src/Classic/Fields/Astra1D_fast.h
+++ b/src/Classic/Fields/Astra1D_fast.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class Astra1D_fast: public Fieldmap {
+class _Astra1D_fast: public _Fieldmap {
public:
+ virtual ~_Astra1D_fast();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const = 0;
virtual bool getFieldDerivative(const Vector_t &R, Vector_t &E, Vector_t &B, const DiffDirection &dir) const = 0;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const = 0;
@@ -18,8 +20,7 @@ public:
virtual bool isInside(const Vector_t &r) const;
protected:
- Astra1D_fast(std::string aFilename);
- virtual ~Astra1D_fast();
+ _Astra1D_fast(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -47,12 +48,14 @@ protected:
int num_gridpz_m;
int numHeaderLines_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool Astra1D_fast::isInside(const Vector_t &r) const
+inline bool _Astra1D_fast::isInside(const Vector_t &r) const
{
return r(2) >= zbegin_m && r(2) < zend_m;
}
+using Astra1D_fast = std::shared_ptr<_Astra1D_fast>;
+
#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/CMakeLists.txt b/src/Classic/Fields/CMakeLists.txt
index 8e695d304c8dd8ea85c356ddb08b622074064ee3..43a9fdbe0be33204baf92fbb8ddeadeb6ea2c038 100644
--- a/src/Classic/Fields/CMakeLists.txt
+++ b/src/Classic/Fields/CMakeLists.txt
@@ -1,42 +1,41 @@
set (_SRCS
+ Astra1DDynamic.cpp
+ Astra1DDynamic_fast.cpp
+ Astra1DElectroStatic.cpp
+ Astra1DElectroStatic_fast.cpp
+ Astra1DMagnetoStatic.cpp
+ Astra1DMagnetoStatic_fast.cpp
+ Astra1D_fast.cpp
BDipoleField.cpp
BMultipoleField.cpp
ConstBField.cpp
ConstBzField.cpp
ConstEzField.cpp
EMField.cpp
- NullField.cpp
- StaticElectricField.cpp
- StaticMagneticField.cpp
- Fieldmap.cpp
- FM3DH5BlockBase.cpp
- FM3DH5Block.cpp
- FM3DH5Block_nonscale.cpp
- FM3DMagnetoStaticH5Block.cpp
- FM3DMagnetoStatic.cpp
- FM3DMagnetoStaticExtended.cpp
- FM3DDynamic.cpp
- FM2DElectroStatic.cpp
- FM2DMagnetoStatic.cpp
- FM2DDynamic.cpp
FM1DDynamic.cpp
FM1DDynamic_fast.cpp
- Astra1D_fast.cpp
- Astra1DDynamic.cpp
- Astra1DDynamic_fast.cpp
FM1DElectroStatic.cpp
FM1DElectroStatic_fast.cpp
- Astra1DElectroStatic.cpp
- Astra1DElectroStatic_fast.cpp
FM1DMagnetoStatic.cpp
FM1DMagnetoStatic_fast.cpp
- Astra1DMagnetoStatic.cpp
- Astra1DMagnetoStatic_fast.cpp
FM1DProfile1.cpp
FM1DProfile2.cpp
- FMDummy.cpp
- SectorMagneticFieldMap.cpp
+ FM2DDynamic.cpp
+ FM2DElectroStatic.cpp
+ FM2DMagnetoStatic.cpp
+ FM3DDynamic.cpp
+ FM3DH5Block.cpp
+ FM3DH5BlockBase.cpp
+ FM3DH5Block_nonscale.cpp
+ FM3DMagnetoStatic.cpp
+ FM3DMagnetoStaticExtended.cpp
+ FM3DMagnetoStaticH5Block.cpp
+ Fieldmap.cpp
+ NullField.cpp
SectorField.cpp
+ SectorMagneticFieldMap.cpp
+ StaticElectricField.cpp
+ StaticMagneticField.cpp
)
include_directories (
@@ -50,13 +49,13 @@ add_opal_sources (${_SRCS})
set (HDRS
AcceleratingField.h
- Astra1DDynamic_fast.h
Astra1DDynamic.h
- Astra1DElectroStatic_fast.h
+ Astra1DDynamic_fast.h
Astra1DElectroStatic.h
- Astra1D_fast.h
- Astra1DMagnetoStatic_fast.h
+ Astra1DElectroStatic_fast.h
Astra1DMagnetoStatic.h
+ Astra1DMagnetoStatic_fast.h
+ Astra1D_fast.h
BDipoleField.h
BMultipoleField.h
BSingleMultipoleField.h
@@ -64,27 +63,26 @@ set (HDRS
ConstBzField.h
ConstEzField.h
EMField.h
- Fieldmap.h
- Fieldmap.hpp
- FM1DDynamic_fast.h
FM1DDynamic.h
- FM1DElectroStatic_fast.h
+ FM1DDynamic_fast.h
FM1DElectroStatic.h
- FM1DMagnetoStatic_fast.h
+ FM1DElectroStatic_fast.h
FM1DMagnetoStatic.h
+ FM1DMagnetoStatic_fast.h
FM1DProfile1.h
FM1DProfile2.h
FM2DDynamic.h
FM2DElectroStatic.h
FM2DMagnetoStatic.h
FM3DDynamic.h
- FM3DH5BlockBase.h
FM3DH5Block.h
+ FM3DH5BlockBase.h
FM3DH5Block_nonscale.h
- FM3DMagnetoStaticH5Block.h
FM3DMagnetoStatic.h
FM3DMagnetoStaticExtended.h
- FMDummy.h
+ FM3DMagnetoStaticH5Block.h
+ Fieldmap.h
+ Fieldmap.hpp
NullField.h
OscillatingField.h
SectorField.h
@@ -93,4 +91,4 @@ set (HDRS
StaticMagneticField.h
)
-install (FILES ${HDRS} DESTINATION "${CMAKE_INSTALL_PREFIX}/include/Fields")
+install (FILES ${HDRS} DESTINATION "${CMAKE_INSTALL_PREFIX}/include/Fields")
\ No newline at end of file
diff --git a/src/Classic/Fields/Definitions.h b/src/Classic/Fields/Definitions.h
new file mode 100644
index 0000000000000000000000000000000000000000..fc4a3cb864fd32e42533429b84f55be3b45bff54
--- /dev/null
+++ b/src/Classic/Fields/Definitions.h
@@ -0,0 +1,75 @@
+#pragma once
+
+#include <memory>
+
+class _Astra1DDynamic;
+using Astra1DDynamic = std::shared_ptr<_Astra1DDynamic>;
+
+class _Astra1DDynamic_fast;
+using Astra1DDynamic_fast = std::shared_ptr<_Astra1DDynamic_fast>;
+
+class _Astra1DElectroStatic;
+using Astra1DElectroStatic = std::shared_ptr<_Astra1DElectroStatic>;
+
+class _Astra1DElectroStatic_fast;
+using Astra1DElectroStatic_fast = std::shared_ptr<_Astra1DElectroStatic_fast>;
+
+class _Astra1DMagnetoStatic;
+using Astra1DMagnetoStatic = std::shared_ptr<_Astra1DMagnetoStatic>;
+
+class _Astra1DMagnetoStatic_fast;
+using Astra1DMagnetoStatic_fast = std::shared_ptr<_Astra1DMagnetoStatic_fast>;
+
+class _Fieldmap;
+using Fieldmap = std::shared_ptr<_Fieldmap>;
+
+class _FM1DDynamic;
+using FM1DDynamic = std::shared_ptr<_FM1DDynamic>;
+
+class _FM1DDynamic_fast;
+using FM1DDynamic_fast = std::shared_ptr<_FM1DDynamic_fast>;
+
+class _FM1DElectroStatic;
+using FM1DElectroStatic = std::shared_ptr<_FM1DElectroStatic>;
+
+class _FM1DElectroStatic_fast;
+using FM1DElectroStatic_fast = std::shared_ptr<_FM1DElectroStatic_fast>;
+
+class _FM1DMagnetoStatic;
+using FM1DMagnetoStatic = std::shared_ptr<_FM1DMagnetoStatic>;
+
+class _FM1DMagnetoStatic_fast;
+using FM1DMagnetoStatic_fast = std::shared_ptr<_FM1DMagnetoStatic_fast>;
+
+class _FM1DProfile1;
+using FM1DProfile1 = std::shared_ptr<_FM1DProfile1>;
+
+class _FM1DProfile2;
+using FM1DProfile2 = std::shared_ptr<_FM1DProfile2>;
+
+class _FM2DDynamic;
+using FM2DDynamic = std::shared_ptr<_FM2DDynamic>;
+
+class _FM2DElectroStatic;
+using FM2DElectroStatic = std::shared_ptr<_FM2DElectroStatic>;
+
+class _FM2DMagnetoStatic;
+using FM2DMagnetoStatic = std::shared_ptr<_FM2DMagnetoStatic>;
+
+class _FM3DDynamic;
+using FM3DDynamic = std::shared_ptr<_FM3DDynamic>;
+
+class _FM3DH5Block;
+using FM3DH5Block = std::shared_ptr<_FM3DH5Block>;
+
+class _FM3DH5Block_nonscale;
+using FM3DH5Block_nonscale = std::shared_ptr<_FM3DH5Block_nonscale>;
+
+class _FM3DMagnetoStatic;
+using FM3DMagnetoStatic = std::shared_ptr<_FM3DMagnetoStatic>;
+
+class _FM3DMagnetoStaticExtended;
+using FM3DMagnetoStaticExtended = std::shared_ptr<_FM3DMagnetoStaticExtended>;
+
+class _FM3DMagnetoStaticH5Block;
+using FM3DMagnetoStaticH5Block = std::shared_ptr<_FM3DMagnetoStaticH5Block>;
\ No newline at end of file
diff --git a/src/Classic/Fields/FM1DDynamic.cpp b/src/Classic/Fields/FM1DDynamic.cpp
index a226c4cd41749638c6b1e693d69b70b76173a99f..9b350566e13366d6cd64064ae578509a9b362a5f 100644
--- a/src/Classic/Fields/FM1DDynamic.cpp
+++ b/src/Classic/Fields/FM1DDynamic.cpp
@@ -10,8 +10,8 @@
#include <fstream>
#include <iostream>
-FM1DDynamic::FM1DDynamic(std::string aFilename):
- Fieldmap(aFilename) {
+_FM1DDynamic::_FM1DDynamic(const std::string& filename):
+ _Fieldmap(filename) {
Type = T1DDynamic;
@@ -38,11 +38,15 @@ FM1DDynamic::FM1DDynamic(std::string aFilename):
}
}
-FM1DDynamic::~FM1DDynamic() {
+_FM1DDynamic::~_FM1DDynamic() {
freeMap();
}
-void FM1DDynamic::readMap() {
+FM1DDynamic _FM1DDynamic::create(const std::string& filename) {
+ return FM1DDynamic(new _FM1DDynamic(filename));
+}
+
+void _FM1DDynamic::readMap() {
if(fourierCoefs_m.empty()) {
@@ -59,17 +63,14 @@ void FM1DDynamic::readMap() {
}
}
-void FM1DDynamic::freeMap() {
+void _FM1DDynamic::freeMap() {
if(!fourierCoefs_m.empty()) {
fourierCoefs_m.clear();
-
- INFOMSG(typeset_msg("Freed field map '" + Filename_m + "'", "info")
- << endl);
}
}
-bool FM1DDynamic::getFieldstrength(const Vector_t &R, Vector_t &E,
+bool _FM1DDynamic::getFieldstrength(const Vector_t &R, Vector_t &E,
Vector_t &B) const {
std::vector<double> fieldComponents;
@@ -79,7 +80,7 @@ bool FM1DDynamic::getFieldstrength(const Vector_t &R, Vector_t &E,
return false;
}
-bool FM1DDynamic::getFieldDerivative(const Vector_t &R,
+bool _FM1DDynamic::getFieldDerivative(const Vector_t &R,
Vector_t &E,
Vector_t &/*B*/,
const DiffDirection &/*dir*/) const {
@@ -102,35 +103,35 @@ bool FM1DDynamic::getFieldDerivative(const Vector_t &R,
return false;
}
-void FM1DDynamic::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _FM1DDynamic::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zBegin_m;
zEnd = zEnd_m;
}
-void FM1DDynamic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/,
+void _FM1DDynamic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/,
double &/*yIni*/, double &/*yFinal*/,
double &/*zIni*/, double &/*zFinal*/) const {
}
-void FM1DDynamic::swap()
+void _FM1DDynamic::swap()
{ }
-void FM1DDynamic::getInfo(Inform *msg) {
+void _FM1DDynamic::getInfo(Inform *msg) {
(*msg) << Filename_m
<< " (1D dynamic); zini= "
<< zBegin_m << " m; zfinal= "
<< zEnd_m << " m;" << endl;
}
-double FM1DDynamic::getFrequency() const {
+double _FM1DDynamic::getFrequency() const {
return frequency_m;
}
-void FM1DDynamic::setFrequency(double frequency) {
+void _FM1DDynamic::setFrequency(double frequency) {
frequency_m = frequency;
}
-void FM1DDynamic::getOnaxisEz(std::vector<std::pair<double, double> > &eZ) {
+void _FM1DDynamic::getOnaxisEz(std::vector<std::pair<double, double> > &eZ) {
eZ.resize(numberOfGridPoints_m);
std::ifstream fieldFile(Filename_m.c_str());
@@ -141,7 +142,7 @@ void FM1DDynamic::getOnaxisEz(std::vector<std::pair<double, double> > &eZ) {
}
-bool FM1DDynamic::checkFileData(std::ifstream &fieldFile, bool parsingPassed) {
+bool _FM1DDynamic::checkFileData(std::ifstream &fieldFile, bool parsingPassed) {
double tempDouble;
for(int dataIndex = 0; dataIndex < numberOfGridPoints_m; ++ dataIndex)
@@ -152,7 +153,7 @@ bool FM1DDynamic::checkFileData(std::ifstream &fieldFile, bool parsingPassed) {
}
-void FM1DDynamic::computeFieldOffAxis(const Vector_t &R,
+void _FM1DDynamic::computeFieldOffAxis(const Vector_t &R,
Vector_t &E,
Vector_t &B,
std::vector<double> fieldComponents) const {
@@ -177,7 +178,7 @@ void FM1DDynamic::computeFieldOffAxis(const Vector_t &R,
}
-void FM1DDynamic::computeFieldOnAxis(double z,
+void _FM1DDynamic::computeFieldOnAxis(double z,
std::vector<double> &fieldComponents) const {
double kz = Physics::two_pi * z / length_m + Physics::pi;
@@ -210,7 +211,7 @@ void FM1DDynamic::computeFieldOnAxis(double z,
}
}
-void FM1DDynamic::computeFourierCoefficients(double maxEz, double fieldData[]) {
+void _FM1DDynamic::computeFourierCoefficients(double maxEz, double fieldData[]) {
const unsigned int totalSize = 2 * numberOfGridPoints_m - 1;
gsl_fft_real_wavetable *waveTable = gsl_fft_real_wavetable_alloc(totalSize);
gsl_fft_real_workspace *workSpace = gsl_fft_real_workspace_alloc(totalSize);
@@ -231,7 +232,7 @@ void FM1DDynamic::computeFourierCoefficients(double maxEz, double fieldData[]) {
}
-void FM1DDynamic::convertHeaderData() {
+void _FM1DDynamic::convertHeaderData() {
// Convert to angular frequency in Hz.
frequency_m *= Physics::two_pi * Units::MHz2Hz;
@@ -245,7 +246,7 @@ void FM1DDynamic::convertHeaderData() {
twoPiOverLambdaSq_m = pow(frequency_m / Physics::c, 2.0);
}
-double FM1DDynamic::readFileData(std::ifstream &fieldFile, double fieldData[]) {
+double _FM1DDynamic::readFileData(std::ifstream &fieldFile, double fieldData[]) {
double maxEz = 0.0;
for(int dataIndex = 0; dataIndex < numberOfGridPoints_m; ++ dataIndex) {
@@ -269,7 +270,7 @@ double FM1DDynamic::readFileData(std::ifstream &fieldFile, double fieldData[]) {
return maxEz;
}
-double FM1DDynamic::readFileData(std::ifstream &fieldFile,
+double _FM1DDynamic::readFileData(std::ifstream &fieldFile,
std::vector<std::pair<double, double>> &eZ) {
double maxEz = 0.0;
@@ -287,7 +288,7 @@ double FM1DDynamic::readFileData(std::ifstream &fieldFile,
return maxEz;
}
-bool FM1DDynamic::readFileHeader(std::ifstream &fieldFile) {
+bool _FM1DDynamic::readFileHeader(std::ifstream &fieldFile) {
std::string tempString;
int tempInt;
@@ -306,7 +307,7 @@ bool FM1DDynamic::readFileHeader(std::ifstream &fieldFile) {
tempString = Util::toUpper(tempString);
if (tempString != "TRUE" &&
tempString != "FALSE")
- throw GeneralClassicException("FM1DDynamic::FM1DDynamic",
+ throw GeneralClassicException("_FM1DDynamic::_FM1DDynamic",
"The third string on the first line of 1D field "
"maps has to be either TRUE or FALSE");
@@ -334,12 +335,12 @@ bool FM1DDynamic::readFileHeader(std::ifstream &fieldFile) {
return parsingPassed;
}
-void FM1DDynamic::scaleField(double maxEz, std::vector<std::pair<double, double>> &eZ) {
+void _FM1DDynamic::scaleField(double maxEz, std::vector<std::pair<double, double>> &eZ) {
for(int dataIndex = 0; dataIndex < numberOfGridPoints_m; ++ dataIndex)
eZ.at(dataIndex).second /= maxEz;
}
-void FM1DDynamic::stripFileHeader(std::ifstream &fieldFile) {
+void _FM1DDynamic::stripFileHeader(std::ifstream &fieldFile) {
std::string tempString;
@@ -347,4 +348,4 @@ void FM1DDynamic::stripFileHeader(std::ifstream &fieldFile) {
getLine(fieldFile, tempString);
getLine(fieldFile, tempString);
getLine(fieldFile, tempString);
-}
\ No newline at end of file
+}
diff --git a/src/Classic/Fields/FM1DDynamic.h b/src/Classic/Fields/FM1DDynamic.h
index 29e15f0ef3f6be8be974ad8ed07aa13a6a415ce8..6415e8ee926954f71d6b98a688f529b797c4a63c 100644
--- a/src/Classic/Fields/FM1DDynamic.h
+++ b/src/Classic/Fields/FM1DDynamic.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class FM1DDynamic: public Fieldmap {
+class _FM1DDynamic: public _Fieldmap {
public:
+ virtual ~_FM1DDynamic();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual bool getFieldDerivative(const Vector_t &R, Vector_t &E,
Vector_t &B, const DiffDirection &dir) const;
@@ -21,9 +23,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- FM1DDynamic(std::string aFilename);
- ~FM1DDynamic();
+ _FM1DDynamic(const std::string& filename);
+ static FM1DDynamic create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -54,12 +56,14 @@ private:
int accuracy_m; /// Number of Fourier coefficients to use reconstructing field.
std::vector<double> fourierCoefs_m; /// Fourier coefficients derived from field map.
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool FM1DDynamic::isInside(const Vector_t &r) const
+inline bool _FM1DDynamic::isInside(const Vector_t &r) const
{
return r(2) >= zBegin_m && r(2) < zEnd_m;
}
-#endif
+using FM1DDynamic = std::shared_ptr<_FM1DDynamic>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM1DDynamic_fast.cpp b/src/Classic/Fields/FM1DDynamic_fast.cpp
index b34ad643a945c554f66bf02470232fc0d1fa9bcd..8e1668537df5bf12e69ce7e5fea72958052fb613 100644
--- a/src/Classic/Fields/FM1DDynamic_fast.cpp
+++ b/src/Classic/Fields/FM1DDynamic_fast.cpp
@@ -10,8 +10,8 @@
#include <fstream>
#include <ios>
-FM1DDynamic_fast::FM1DDynamic_fast(std::string aFilename):
- Fieldmap(aFilename),
+_FM1DDynamic_fast::_FM1DDynamic_fast(const std::string& filename):
+ _Fieldmap(filename),
accuracy_m(0)
{
@@ -41,11 +41,15 @@ FM1DDynamic_fast::FM1DDynamic_fast(std::string aFilename):
}
}
-FM1DDynamic_fast::~FM1DDynamic_fast() {
+_FM1DDynamic_fast::~_FM1DDynamic_fast() {
freeMap();
}
-void FM1DDynamic_fast::readMap() {
+FM1DDynamic_fast _FM1DDynamic_fast::create(const std::string& filename) {
+ return FM1DDynamic_fast(new _FM1DDynamic_fast(filename));
+}
+
+void _FM1DDynamic_fast::readMap() {
if (onAxisField_m == nullptr) {
@@ -78,7 +82,7 @@ void FM1DDynamic_fast::readMap() {
}
}
-void FM1DDynamic_fast::freeMap() {
+void _FM1DDynamic_fast::freeMap() {
if (onAxisField_m != nullptr) {
delete [] onAxisField_m;
onAxisField_m = nullptr;
@@ -91,13 +95,10 @@ void FM1DDynamic_fast::freeMap() {
gsl_interp_accel_free(onAxisFieldPAccel_m);
gsl_interp_accel_free(onAxisFieldPPAccel_m);
gsl_interp_accel_free(onAxisFieldPPPAccel_m);
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info")
- << endl);
}
}
-bool FM1DDynamic_fast::getFieldstrength(const Vector_t &R, Vector_t &E,
+bool _FM1DDynamic_fast::getFieldstrength(const Vector_t &R, Vector_t &E,
Vector_t &B) const {
std::vector<double> fieldComponents;
@@ -107,7 +108,7 @@ bool FM1DDynamic_fast::getFieldstrength(const Vector_t &R, Vector_t &E,
return false;
}
-bool FM1DDynamic_fast::getFieldDerivative(const Vector_t &R,
+bool _FM1DDynamic_fast::getFieldDerivative(const Vector_t &R,
Vector_t &E,
Vector_t &/*B*/,
const DiffDirection &/*dir*/) const {
@@ -118,34 +119,34 @@ bool FM1DDynamic_fast::getFieldDerivative(const Vector_t &R,
return false;
}
-void FM1DDynamic_fast::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _FM1DDynamic_fast::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zBegin_m;
zEnd = zEnd_m;
}
-void FM1DDynamic_fast::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/,
+void _FM1DDynamic_fast::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/,
double &/*yIni*/, double &/*yFinal*/,
double &/*zIni*/, double &/*zFinal*/) const {}
-void FM1DDynamic_fast::swap()
+void _FM1DDynamic_fast::swap()
{ }
-void FM1DDynamic_fast::getInfo(Inform *msg) {
+void _FM1DDynamic_fast::getInfo(Inform *msg) {
(*msg) << Filename_m
<< " (1D dynamic); zini= "
<< zBegin_m << " m; zfinal= "
<< zEnd_m << " m;" << endl;
}
-double FM1DDynamic_fast::getFrequency() const {
+double _FM1DDynamic_fast::getFrequency() const {
return frequency_m;
}
-void FM1DDynamic_fast::setFrequency(double freq) {
+void _FM1DDynamic_fast::setFrequency(double freq) {
frequency_m = freq;
}
-void FM1DDynamic_fast::getOnaxisEz(std::vector<std::pair<double, double>> &eZ) {
+void _FM1DDynamic_fast::getOnaxisEz(std::vector<std::pair<double, double>> &eZ) {
eZ.resize(numberOfGridPoints_m);
std::ifstream fieldFile(Filename_m.c_str());
@@ -156,7 +157,7 @@ void FM1DDynamic_fast::getOnaxisEz(std::vector<std::pair<double, double>> &eZ) {
}
-bool FM1DDynamic_fast::checkFileData(std::ifstream &fieldFile,
+bool _FM1DDynamic_fast::checkFileData(std::ifstream &fieldFile,
bool parsingPassed) {
double tempDouble;
@@ -168,7 +169,7 @@ bool FM1DDynamic_fast::checkFileData(std::ifstream &fieldFile,
}
-void FM1DDynamic_fast::computeFieldDerivatives(std::vector<double> fourierCoefs,
+void _FM1DDynamic_fast::computeFieldDerivatives(std::vector<double> fourierCoefs,
double onAxisFieldP[],
double onAxisFieldPP[],
double onAxisFieldPPP[]) {
@@ -204,7 +205,7 @@ void FM1DDynamic_fast::computeFieldDerivatives(std::vector<double> fourierCoefs,
}
-void FM1DDynamic_fast::computeFieldOffAxis(const Vector_t &R,
+void _FM1DDynamic_fast::computeFieldOffAxis(const Vector_t &R,
Vector_t &E,
Vector_t &B,
std::vector<double> fieldComponents) const {
@@ -228,7 +229,7 @@ void FM1DDynamic_fast::computeFieldOffAxis(const Vector_t &R,
}
-void FM1DDynamic_fast::computeFieldOnAxis(double z,
+void _FM1DDynamic_fast::computeFieldOnAxis(double z,
std::vector<double> &fieldComponents)
const {
@@ -242,7 +243,7 @@ void FM1DDynamic_fast::computeFieldOnAxis(double z,
z, onAxisFieldPPPAccel_m));
}
-std::vector<double> FM1DDynamic_fast::computeFourierCoefficients(double fieldData[]) {
+std::vector<double> _FM1DDynamic_fast::computeFourierCoefficients(double fieldData[]) {
const unsigned int totalSize = 2 * numberOfGridPoints_m - 1;
gsl_fft_real_wavetable *waveTable = gsl_fft_real_wavetable_alloc(totalSize);
gsl_fft_real_workspace *workSpace = gsl_fft_real_workspace_alloc(totalSize);
@@ -274,7 +275,7 @@ std::vector<double> FM1DDynamic_fast::computeFourierCoefficients(double fieldDat
}
-void FM1DDynamic_fast::computeInterpolationVectors(double onAxisFieldP[],
+void _FM1DDynamic_fast::computeInterpolationVectors(double onAxisFieldP[],
double onAxisFieldPP[],
double onAxisFieldPPP[]) {
@@ -307,7 +308,7 @@ void FM1DDynamic_fast::computeInterpolationVectors(double onAxisFieldP[],
delete [] z;
}
-void FM1DDynamic_fast::convertHeaderData() {
+void _FM1DDynamic_fast::convertHeaderData() {
// Convert to angular frequency in Hz.
frequency_m *= Physics::two_pi * Units::MHz2Hz;
@@ -321,7 +322,7 @@ void FM1DDynamic_fast::convertHeaderData() {
twoPiOverLambdaSq_m = pow(frequency_m / Physics::c, 2.0);
}
-void FM1DDynamic_fast::normalizeField(double maxEz,
+void _FM1DDynamic_fast::normalizeField(double maxEz,
std::vector<double> &fourierCoefs) {
for (unsigned int dataIndex = 0; dataIndex < numberOfGridPoints_m; ++ dataIndex)
@@ -333,7 +334,7 @@ void FM1DDynamic_fast::normalizeField(double maxEz,
}
-double FM1DDynamic_fast::readFileData(std::ifstream &fieldFile,
+double _FM1DDynamic_fast::readFileData(std::ifstream &fieldFile,
double fieldData[]) {
double maxEz = 0.0;
@@ -349,7 +350,7 @@ double FM1DDynamic_fast::readFileData(std::ifstream &fieldFile,
return maxEz;
}
-double FM1DDynamic_fast::readFileData(std::ifstream &fieldFile,
+double _FM1DDynamic_fast::readFileData(std::ifstream &fieldFile,
std::vector<std::pair<double, double>> &eZ) {
double maxEz = 0.0;
@@ -367,7 +368,7 @@ double FM1DDynamic_fast::readFileData(std::ifstream &fieldFile,
return maxEz;
}
-bool FM1DDynamic_fast::readFileHeader(std::ifstream &fieldFile) {
+bool _FM1DDynamic_fast::readFileHeader(std::ifstream &fieldFile) {
std::string tempString;
int tempInt;
@@ -386,7 +387,7 @@ bool FM1DDynamic_fast::readFileHeader(std::ifstream &fieldFile) {
tempString = Util::toUpper(tempString);
if (tempString != "TRUE" &&
tempString != "FALSE")
- throw GeneralClassicException("FM1DDynamic_fast::readFileHeader",
+ throw GeneralClassicException("_FM1DDynamic_fast::readFileHeader",
"The third string on the first line of 1D field "
"maps has to be either TRUE or FALSE");
@@ -413,7 +414,7 @@ bool FM1DDynamic_fast::readFileHeader(std::ifstream &fieldFile) {
return parsingPassed;
}
-void FM1DDynamic_fast::scaleField(double maxEz,
+void _FM1DDynamic_fast::scaleField(double maxEz,
std::vector<std::pair<double, double>> &eZ) {
if (!normalize_m) return;
@@ -421,7 +422,7 @@ void FM1DDynamic_fast::scaleField(double maxEz,
eZ.at(dataIndex).second /= maxEz;
}
-void FM1DDynamic_fast::stripFileHeader(std::ifstream &fieldFile) {
+void _FM1DDynamic_fast::stripFileHeader(std::ifstream &fieldFile) {
std::string tempString;
@@ -431,7 +432,7 @@ void FM1DDynamic_fast::stripFileHeader(std::ifstream &fieldFile) {
getLine(fieldFile, tempString);
}
-void FM1DDynamic_fast::prepareForMapCheck(std::vector<double> &fourierCoefs) {
+void _FM1DDynamic_fast::prepareForMapCheck(std::vector<double> &fourierCoefs) {
std::vector<double> zSampling(numberOfGridPoints_m);
for (unsigned int zStepIndex = 0; zStepIndex < numberOfGridPoints_m; ++ zStepIndex)
zSampling[zStepIndex] = deltaZ_m * zStepIndex;
diff --git a/src/Classic/Fields/FM1DDynamic_fast.h b/src/Classic/Fields/FM1DDynamic_fast.h
index da5db0e11767cd1779b63c4d81538ab4b82985ee..baa286c7c4546e074871e9cf4c659d0769a898e5 100644
--- a/src/Classic/Fields/FM1DDynamic_fast.h
+++ b/src/Classic/Fields/FM1DDynamic_fast.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class FM1DDynamic_fast: public Fieldmap {
+class _FM1DDynamic_fast: public _Fieldmap {
public:
+ virtual ~_FM1DDynamic_fast();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual bool getFieldDerivative(const Vector_t &R, Vector_t &E,
Vector_t &B, const DiffDirection &dir) const;
@@ -21,8 +23,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- FM1DDynamic_fast(std::string aFilename);
- ~FM1DDynamic_fast();
+ _FM1DDynamic_fast(const std::string& filename);
+
+ static FM1DDynamic_fast create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -73,12 +76,14 @@ private:
gsl_interp_accel *onAxisFieldPPAccel_m;
gsl_interp_accel *onAxisFieldPPPAccel_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool FM1DDynamic_fast::isInside(const Vector_t &r) const
+inline bool _FM1DDynamic_fast::isInside(const Vector_t &r) const
{
return r(2) >= zBegin_m && r(2) < zEnd_m;
}
-#endif
+using FM1DDynamic_fast = std::shared_ptr<_FM1DDynamic_fast>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM1DElectroStatic.cpp b/src/Classic/Fields/FM1DElectroStatic.cpp
index ee3bf09642abb0f3c13c602fe427697a425e575b..04d8e5db2dc87d0d4de84d819b733909eed544f6 100644
--- a/src/Classic/Fields/FM1DElectroStatic.cpp
+++ b/src/Classic/Fields/FM1DElectroStatic.cpp
@@ -10,8 +10,8 @@
#include <fstream>
#include <ios>
-FM1DElectroStatic::FM1DElectroStatic(std::string aFilename):
- Fieldmap(aFilename) {
+_FM1DElectroStatic::_FM1DElectroStatic(const std::string& filename):
+ _Fieldmap(filename) {
Type = T1DElectroStatic;
@@ -37,11 +37,16 @@ FM1DElectroStatic::FM1DElectroStatic(std::string aFilename):
}
}
-FM1DElectroStatic::~FM1DElectroStatic() {
+_FM1DElectroStatic::~_FM1DElectroStatic() {
freeMap();
}
-void FM1DElectroStatic::readMap() {
+FM1DElectroStatic _FM1DElectroStatic::create(const std::string& filename)
+{
+ return FM1DElectroStatic(new _FM1DElectroStatic(filename));
+}
+
+void _FM1DElectroStatic::readMap() {
if (fourierCoefs_m.empty()) {
@@ -59,17 +64,14 @@ void FM1DElectroStatic::readMap() {
}
}
-void FM1DElectroStatic::freeMap() {
+void _FM1DElectroStatic::freeMap() {
if (!fourierCoefs_m.empty()) {
fourierCoefs_m.clear();
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info")
- << endl);
}
}
-bool FM1DElectroStatic::getFieldstrength(const Vector_t &R, Vector_t &E,
+bool _FM1DElectroStatic::getFieldstrength(const Vector_t &R, Vector_t &E,
Vector_t &B) const {
std::vector<double> fieldComponents;
@@ -79,7 +81,7 @@ bool FM1DElectroStatic::getFieldstrength(const Vector_t &R, Vector_t &E,
return false;
}
-bool FM1DElectroStatic::getFieldDerivative(const Vector_t &R,
+bool _FM1DElectroStatic::getFieldDerivative(const Vector_t &R,
Vector_t &E,
Vector_t &/*B*/,
const DiffDirection &/*dir*/) const {
@@ -102,32 +104,32 @@ bool FM1DElectroStatic::getFieldDerivative(const Vector_t &R,
return false;
}
-void FM1DElectroStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _FM1DElectroStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zBegin_m;
zEnd = zEnd_m;
}
-void FM1DElectroStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/,
+void _FM1DElectroStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/,
double &/*yIni*/, double &/*yFinal*/,
double &/*zIni*/, double &/*zFinal*/) const {}
-void FM1DElectroStatic::swap()
+void _FM1DElectroStatic::swap()
{ }
-void FM1DElectroStatic::getInfo(Inform *msg) {
+void _FM1DElectroStatic::getInfo(Inform *msg) {
(*msg) << Filename_m
<< " (1D electrostatic); zini= "
<< zBegin_m << " m; zfinal= "
<< zEnd_m << " m;" << endl;
}
-double FM1DElectroStatic::getFrequency() const {
+double _FM1DElectroStatic::getFrequency() const {
return 0.0;
}
-void FM1DElectroStatic::setFrequency(double /*freq*/)
+void _FM1DElectroStatic::setFrequency(double /*freq*/)
{ }
-bool FM1DElectroStatic::checkFileData(std::ifstream &fieldFile,
+bool _FM1DElectroStatic::checkFileData(std::ifstream &fieldFile,
bool parsingPassed) {
double tempDouble;
@@ -139,7 +141,7 @@ bool FM1DElectroStatic::checkFileData(std::ifstream &fieldFile,
}
-void FM1DElectroStatic::computeFieldOffAxis(const Vector_t &R,
+void _FM1DElectroStatic::computeFieldOffAxis(const Vector_t &R,
Vector_t &E,
Vector_t &/*B*/,
std::vector<double> fieldComponents) const {
@@ -154,7 +156,7 @@ void FM1DElectroStatic::computeFieldOffAxis(const Vector_t &R,
}
-void FM1DElectroStatic::computeFieldOnAxis(double z,
+void _FM1DElectroStatic::computeFieldOnAxis(double z,
std::vector<double> &fieldComponents) const {
double kz = Physics::two_pi * z / length_m + Physics::pi;
@@ -187,7 +189,7 @@ void FM1DElectroStatic::computeFieldOnAxis(double z,
}
}
-void FM1DElectroStatic::computeFourierCoefficients(double maxEz,
+void _FM1DElectroStatic::computeFourierCoefficients(double maxEz,
double fieldData[]) {
const unsigned int totalSize = 2 * numberOfGridPoints_m - 1;
gsl_fft_real_wavetable *waveTable = gsl_fft_real_wavetable_alloc(totalSize);
@@ -209,7 +211,7 @@ void FM1DElectroStatic::computeFourierCoefficients(double maxEz,
}
-void FM1DElectroStatic::convertHeaderData() {
+void _FM1DElectroStatic::convertHeaderData() {
// Convert to m.
rBegin_m *= Units::cm2m;
@@ -218,7 +220,7 @@ void FM1DElectroStatic::convertHeaderData() {
zEnd_m *= Units::cm2m;
}
-double FM1DElectroStatic::readFileData(std::ifstream &fieldFile,
+double _FM1DElectroStatic::readFileData(std::ifstream &fieldFile,
double fieldData[]) {
double maxEz = 0.0;
@@ -243,7 +245,7 @@ double FM1DElectroStatic::readFileData(std::ifstream &fieldFile,
return maxEz;
}
-bool FM1DElectroStatic::readFileHeader(std::ifstream &fieldFile) {
+bool _FM1DElectroStatic::readFileHeader(std::ifstream &fieldFile) {
std::string tempString;
int tempInt;
@@ -262,7 +264,7 @@ bool FM1DElectroStatic::readFileHeader(std::ifstream &fieldFile) {
tempString = Util::toUpper(tempString);
if (tempString != "TRUE" &&
tempString != "FALSE")
- throw GeneralClassicException("FM1DElectroStatic::readFileHeader",
+ throw GeneralClassicException("_FM1DElectroStatic::readFileHeader",
"The third string on the first line of 1D field "
"maps has to be either TRUE or FALSE");
@@ -286,11 +288,11 @@ bool FM1DElectroStatic::readFileHeader(std::ifstream &fieldFile) {
return parsingPassed;
}
-void FM1DElectroStatic::stripFileHeader(std::ifstream &fieldFile) {
+void _FM1DElectroStatic::stripFileHeader(std::ifstream &fieldFile) {
std::string tempString;
getLine(fieldFile, tempString);
getLine(fieldFile, tempString);
getLine(fieldFile, tempString);
-}
\ No newline at end of file
+}
diff --git a/src/Classic/Fields/FM1DElectroStatic.h b/src/Classic/Fields/FM1DElectroStatic.h
index d67ce07fca153bbc2623e0b854b21748d7152756..173a9c6f7d25eb9538d56e85348e1e791c5811c3 100644
--- a/src/Classic/Fields/FM1DElectroStatic.h
+++ b/src/Classic/Fields/FM1DElectroStatic.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class FM1DElectroStatic: public Fieldmap {
+class _FM1DElectroStatic: public _Fieldmap {
public:
+ virtual ~_FM1DElectroStatic();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
virtual void getFieldDimensions(double &xIni, double &xFinal,
@@ -20,8 +22,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- FM1DElectroStatic(std::string aFilename);
- ~FM1DElectroStatic();
+ _FM1DElectroStatic(const std::string& filename);
+
+ static FM1DElectroStatic create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -47,12 +50,14 @@ private:
int accuracy_m; /// Number of Fourier coefficients to use reconstructing field.
std::vector<double> fourierCoefs_m; /// Fourier coefficients derived from field map.
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool FM1DElectroStatic::isInside(const Vector_t &r) const
+inline bool _FM1DElectroStatic::isInside(const Vector_t &r) const
{
return r(2) >= zBegin_m && r(2) < zEnd_m;
}
-#endif
+using FM1DElectroStatic = std::shared_ptr<_FM1DElectroStatic>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM1DElectroStatic_fast.cpp b/src/Classic/Fields/FM1DElectroStatic_fast.cpp
index 111dc102b90aa43257e835182353e75fae6991cc..cbc591ca23df6faffee027fb6d893dfc72c59a1d 100644
--- a/src/Classic/Fields/FM1DElectroStatic_fast.cpp
+++ b/src/Classic/Fields/FM1DElectroStatic_fast.cpp
@@ -10,8 +10,8 @@
#include <fstream>
#include <ios>
-FM1DElectroStatic_fast::FM1DElectroStatic_fast(std::string aFilename):
- Fieldmap(aFilename),
+_FM1DElectroStatic_fast::_FM1DElectroStatic_fast(const std::string& filename):
+ _Fieldmap(filename),
accuracy_m(0)
{
@@ -41,11 +41,16 @@ FM1DElectroStatic_fast::FM1DElectroStatic_fast(std::string aFilename):
}
}
-FM1DElectroStatic_fast::~FM1DElectroStatic_fast() {
+_FM1DElectroStatic_fast::~_FM1DElectroStatic_fast() {
freeMap();
}
-void FM1DElectroStatic_fast::readMap() {
+FM1DElectroStatic_fast _FM1DElectroStatic_fast::create(const std::string& filename)
+{
+ return FM1DElectroStatic_fast(new _FM1DElectroStatic_fast(filename));
+}
+
+void _FM1DElectroStatic_fast::readMap() {
if (onAxisField_m == nullptr) {
std::ifstream fieldFile(Filename_m.c_str());
@@ -78,7 +83,7 @@ void FM1DElectroStatic_fast::readMap() {
}
}
-void FM1DElectroStatic_fast::freeMap() {
+void _FM1DElectroStatic_fast::freeMap() {
if (onAxisField_m != nullptr) {
delete [] onAxisField_m;
onAxisField_m = nullptr;
@@ -91,13 +96,10 @@ void FM1DElectroStatic_fast::freeMap() {
gsl_interp_accel_free(onAxisFieldPAccel_m);
gsl_interp_accel_free(onAxisFieldPPAccel_m);
gsl_interp_accel_free(onAxisFieldPPPAccel_m);
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info")
- << endl);
}
}
-bool FM1DElectroStatic_fast::getFieldstrength(const Vector_t &R, Vector_t &E,
+bool _FM1DElectroStatic_fast::getFieldstrength(const Vector_t &R, Vector_t &E,
Vector_t &B) const {
std::vector<double> fieldComponents;
@@ -108,7 +110,7 @@ bool FM1DElectroStatic_fast::getFieldstrength(const Vector_t &R, Vector_t &E,
}
-bool FM1DElectroStatic_fast::getFieldDerivative(const Vector_t &R,
+bool _FM1DElectroStatic_fast::getFieldDerivative(const Vector_t &R,
Vector_t &E,
Vector_t &/*B*/,
const DiffDirection &/*dir*/) const {
@@ -120,32 +122,32 @@ bool FM1DElectroStatic_fast::getFieldDerivative(const Vector_t &R,
}
-void FM1DElectroStatic_fast::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _FM1DElectroStatic_fast::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zBegin_m;
zEnd = zEnd_m;
}
-void FM1DElectroStatic_fast::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/,
+void _FM1DElectroStatic_fast::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/,
double &/*yIni*/, double &/*yFinal*/,
double &/*zIni*/, double &/*zFinal*/) const {}
-void FM1DElectroStatic_fast::swap()
+void _FM1DElectroStatic_fast::swap()
{ }
-void FM1DElectroStatic_fast::getInfo(Inform *msg) {
+void _FM1DElectroStatic_fast::getInfo(Inform *msg) {
(*msg) << Filename_m
<< " (1D electrotostatic); zini= "
<< zBegin_m << " m; zfinal= "
<< zEnd_m << " m;" << endl;
}
-double FM1DElectroStatic_fast::getFrequency() const {
+double _FM1DElectroStatic_fast::getFrequency() const {
return 0.0;
}
-void FM1DElectroStatic_fast::setFrequency(double /*freq*/)
+void _FM1DElectroStatic_fast::setFrequency(double /*freq*/)
{ }
-bool FM1DElectroStatic_fast::checkFileData(std::ifstream &fieldFile,
+bool _FM1DElectroStatic_fast::checkFileData(std::ifstream &fieldFile,
bool parsingPassed) {
double tempDouble;
@@ -157,7 +159,7 @@ bool FM1DElectroStatic_fast::checkFileData(std::ifstream &fieldFile,
}
-void FM1DElectroStatic_fast::computeFieldDerivatives(std::vector<double> fourierCoefs,
+void _FM1DElectroStatic_fast::computeFieldDerivatives(std::vector<double> fourierCoefs,
double onAxisFieldP[],
double onAxisFieldPP[],
double onAxisFieldPPP[]) {
@@ -192,7 +194,7 @@ void FM1DElectroStatic_fast::computeFieldDerivatives(std::vector<double> fourier
}
}
-void FM1DElectroStatic_fast::computeFieldOffAxis(const Vector_t &R, Vector_t &E, Vector_t &/*B*/,
+void _FM1DElectroStatic_fast::computeFieldOffAxis(const Vector_t &R, Vector_t &E, Vector_t &/*B*/,
std::vector<double> fieldComponents) const {
double radiusSq = pow(R(0), 2.0) + pow(R(1), 2.0);
@@ -205,7 +207,7 @@ void FM1DElectroStatic_fast::computeFieldOffAxis(const Vector_t &R, Vector_t &E,
}
-void FM1DElectroStatic_fast::computeFieldOnAxis(double z,
+void _FM1DElectroStatic_fast::computeFieldOnAxis(double z,
std::vector<double> &fieldComponents) const {
fieldComponents.push_back(gsl_spline_eval(onAxisFieldInterpolants_m,
@@ -218,7 +220,7 @@ void FM1DElectroStatic_fast::computeFieldOnAxis(double z,
z, onAxisFieldPPPAccel_m));
}
-std::vector<double> FM1DElectroStatic_fast::computeFourierCoefficients(double fieldData[]) {
+std::vector<double> _FM1DElectroStatic_fast::computeFourierCoefficients(double fieldData[]) {
const unsigned int totalSize = 2 * numberOfGridPoints_m - 1;
gsl_fft_real_wavetable *waveTable = gsl_fft_real_wavetable_alloc(totalSize);
@@ -250,7 +252,7 @@ std::vector<double> FM1DElectroStatic_fast::computeFourierCoefficients(double fi
}
-void FM1DElectroStatic_fast::computeInterpolationVectors(double onAxisFieldP[],
+void _FM1DElectroStatic_fast::computeInterpolationVectors(double onAxisFieldP[],
double onAxisFieldPP[],
double onAxisFieldPPP[]) {
@@ -284,7 +286,7 @@ void FM1DElectroStatic_fast::computeInterpolationVectors(double onAxisFieldP[],
delete [] z;
}
-void FM1DElectroStatic_fast::convertHeaderData() {
+void _FM1DElectroStatic_fast::convertHeaderData() {
// Convert to m.
rBegin_m *= Units::cm2m;
@@ -294,7 +296,7 @@ void FM1DElectroStatic_fast::convertHeaderData() {
}
-void FM1DElectroStatic_fast::normalizeField(double maxEz, std::vector<double> &fourierCoefs) {
+void _FM1DElectroStatic_fast::normalizeField(double maxEz, std::vector<double> &fourierCoefs) {
for (unsigned int dataIndex = 0; dataIndex < numberOfGridPoints_m; ++ dataIndex)
onAxisField_m[dataIndex] /= (maxEz * Units::Vpm2MVpm);
@@ -304,7 +306,7 @@ void FM1DElectroStatic_fast::normalizeField(double maxEz, std::vector<double> &f
}
-double FM1DElectroStatic_fast::readFileData(std::ifstream &fieldFile,
+double _FM1DElectroStatic_fast::readFileData(std::ifstream &fieldFile,
double fieldData[]) {
double maxEz = 0.0;
@@ -320,7 +322,7 @@ double FM1DElectroStatic_fast::readFileData(std::ifstream &fieldFile,
return maxEz;
}
-bool FM1DElectroStatic_fast::readFileHeader(std::ifstream &fieldFile) {
+bool _FM1DElectroStatic_fast::readFileHeader(std::ifstream &fieldFile) {
std::string tempString;
int tempInt;
@@ -339,7 +341,7 @@ bool FM1DElectroStatic_fast::readFileHeader(std::ifstream &fieldFile) {
tempString = Util::toUpper(tempString);
if (tempString != "TRUE" &&
tempString != "FALSE")
- throw GeneralClassicException("FM1DElectroStatic_fast::readFileHeader",
+ throw GeneralClassicException("_FM1DElectroStatic_fast::readFileHeader",
"The third string on the first line of 1D field "
"maps has to be either TRUE or FALSE");
@@ -363,7 +365,7 @@ bool FM1DElectroStatic_fast::readFileHeader(std::ifstream &fieldFile) {
return parsingPassed;
}
-void FM1DElectroStatic_fast::stripFileHeader(std::ifstream &fieldFile) {
+void _FM1DElectroStatic_fast::stripFileHeader(std::ifstream &fieldFile) {
std::string tempString;
@@ -372,7 +374,7 @@ void FM1DElectroStatic_fast::stripFileHeader(std::ifstream &fieldFile) {
getLine(fieldFile, tempString);
}
-void FM1DElectroStatic_fast::prepareForMapCheck(std::vector<double> &fourierCoefs) {
+void _FM1DElectroStatic_fast::prepareForMapCheck(std::vector<double> &fourierCoefs) {
std::vector<double> zSampling(numberOfGridPoints_m);
for (unsigned int zStepIndex = 0; zStepIndex < numberOfGridPoints_m; ++ zStepIndex)
zSampling[zStepIndex] = deltaZ_m * zStepIndex;
diff --git a/src/Classic/Fields/FM1DElectroStatic_fast.h b/src/Classic/Fields/FM1DElectroStatic_fast.h
index 4861c52dbfb86bdf175e984478f3ebd2015fe6c4..edfc41524ca97844aab7b6112481bc9fa44fd927 100644
--- a/src/Classic/Fields/FM1DElectroStatic_fast.h
+++ b/src/Classic/Fields/FM1DElectroStatic_fast.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class FM1DElectroStatic_fast: public Fieldmap {
+class _FM1DElectroStatic_fast: public _Fieldmap {
public:
+ virtual ~_FM1DElectroStatic_fast();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
virtual void getFieldDimensions(double &xIni, double &xFinal,
@@ -20,8 +22,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- FM1DElectroStatic_fast(std::string aFilename);
- ~FM1DElectroStatic_fast();
+ _FM1DElectroStatic_fast(const std::string& filename);
+
+ static FM1DElectroStatic_fast create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -67,12 +70,14 @@ private:
gsl_interp_accel *onAxisFieldPPAccel_m;
gsl_interp_accel *onAxisFieldPPPAccel_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool FM1DElectroStatic_fast::isInside(const Vector_t &r) const
+inline bool _FM1DElectroStatic_fast::isInside(const Vector_t &r) const
{
return r(2) >= zBegin_m && r(2) < zEnd_m;
}
-#endif
+using FM1DElectroStatic_fast = std::shared_ptr<_FM1DElectroStatic_fast>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM1DMagnetoStatic.cpp b/src/Classic/Fields/FM1DMagnetoStatic.cpp
index 955543e487557032621531478386f822ccc8d405..5ac020752d3159b059a1691cd6db72ef4e84daa4 100644
--- a/src/Classic/Fields/FM1DMagnetoStatic.cpp
+++ b/src/Classic/Fields/FM1DMagnetoStatic.cpp
@@ -10,8 +10,8 @@
#include <fstream>
#include <ios>
-FM1DMagnetoStatic::FM1DMagnetoStatic(std::string aFilename)
- : Fieldmap(aFilename) {
+_FM1DMagnetoStatic::_FM1DMagnetoStatic(const std::string& filename)
+ : _Fieldmap(filename) {
Type = T1DMagnetoStatic;
@@ -37,11 +37,16 @@ FM1DMagnetoStatic::FM1DMagnetoStatic(std::string aFilename)
}
}
-FM1DMagnetoStatic::~FM1DMagnetoStatic() {
+_FM1DMagnetoStatic::~_FM1DMagnetoStatic() {
freeMap();
}
-void FM1DMagnetoStatic::readMap() {
+FM1DMagnetoStatic _FM1DMagnetoStatic::create(const std::string& filename)
+{
+ return FM1DMagnetoStatic(new _FM1DMagnetoStatic(filename));
+}
+
+void _FM1DMagnetoStatic::readMap() {
if(fourierCoefs_m.empty()) {
@@ -59,17 +64,14 @@ void FM1DMagnetoStatic::readMap() {
}
}
-void FM1DMagnetoStatic::freeMap() {
+void _FM1DMagnetoStatic::freeMap() {
if(!fourierCoefs_m.empty()) {
fourierCoefs_m.clear();
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info")
- << endl);
}
}
-bool FM1DMagnetoStatic::getFieldstrength(const Vector_t &R, Vector_t &E,
+bool _FM1DMagnetoStatic::getFieldstrength(const Vector_t &R, Vector_t &E,
Vector_t &B) const {
std::vector<double> fieldComponents;
@@ -79,7 +81,7 @@ bool FM1DMagnetoStatic::getFieldstrength(const Vector_t &R, Vector_t &E,
return false;
}
-bool FM1DMagnetoStatic::getFieldDerivative(const Vector_t &R,
+bool _FM1DMagnetoStatic::getFieldDerivative(const Vector_t &R,
Vector_t &/*E*/,
Vector_t &B,
const DiffDirection &/*dir*/) const {
@@ -102,33 +104,33 @@ bool FM1DMagnetoStatic::getFieldDerivative(const Vector_t &R,
return false;
}
-void FM1DMagnetoStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _FM1DMagnetoStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zBegin_m;
zEnd = zEnd_m;
}
-void FM1DMagnetoStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/,
+void _FM1DMagnetoStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/,
double &/*yIni*/, double &/*yFinal*/,
double &/*zIni*/, double &/*zFinal*/) const {
}
-void FM1DMagnetoStatic::swap()
+void _FM1DMagnetoStatic::swap()
{ }
-void FM1DMagnetoStatic::getInfo(Inform *msg) {
+void _FM1DMagnetoStatic::getInfo(Inform *msg) {
(*msg) << Filename_m
<< " (1D magnetostatic); zini= "
<< zBegin_m << " m; zfinal= "
<< zEnd_m << " m;" << endl;
}
-double FM1DMagnetoStatic::getFrequency() const {
+double _FM1DMagnetoStatic::getFrequency() const {
return 0.0;
}
-void FM1DMagnetoStatic::setFrequency(double /*freq*/)
+void _FM1DMagnetoStatic::setFrequency(double /*freq*/)
{ }
-bool FM1DMagnetoStatic::checkFileData(std::ifstream &fieldFile,
+bool _FM1DMagnetoStatic::checkFileData(std::ifstream &fieldFile,
bool parsingPassed) {
double tempDouble;
@@ -140,7 +142,7 @@ bool FM1DMagnetoStatic::checkFileData(std::ifstream &fieldFile,
}
-void FM1DMagnetoStatic::computeFieldOffAxis(const Vector_t &R,
+void _FM1DMagnetoStatic::computeFieldOffAxis(const Vector_t &R,
Vector_t &/*E*/,
Vector_t &B,
std::vector<double> fieldComponents) const {
@@ -155,7 +157,7 @@ void FM1DMagnetoStatic::computeFieldOffAxis(const Vector_t &R,
}
-void FM1DMagnetoStatic::computeFieldOnAxis(double z,
+void _FM1DMagnetoStatic::computeFieldOnAxis(double z,
std::vector<double> &fieldComponents) const {
double kz = Physics::two_pi * z / length_m + Physics::pi;
@@ -188,7 +190,7 @@ void FM1DMagnetoStatic::computeFieldOnAxis(double z,
}
}
-void FM1DMagnetoStatic::computeFourierCoefficients(double maxBz,
+void _FM1DMagnetoStatic::computeFourierCoefficients(double maxBz,
double fieldData[]) {
const unsigned int totalSize = 2 * numberOfGridPoints_m - 1;
gsl_fft_real_wavetable *waveTable = gsl_fft_real_wavetable_alloc(totalSize);
@@ -210,7 +212,7 @@ void FM1DMagnetoStatic::computeFourierCoefficients(double maxBz,
}
-void FM1DMagnetoStatic::convertHeaderData() {
+void _FM1DMagnetoStatic::convertHeaderData() {
// Convert to m.
rBegin_m *= Units::cm2m;
@@ -219,7 +221,7 @@ void FM1DMagnetoStatic::convertHeaderData() {
zEnd_m *= Units::cm2m;
}
-double FM1DMagnetoStatic::readFileData(std::ifstream &fieldFile,
+double _FM1DMagnetoStatic::readFileData(std::ifstream &fieldFile,
double fieldData[]) {
double maxBz = 0.0;
@@ -244,7 +246,7 @@ double FM1DMagnetoStatic::readFileData(std::ifstream &fieldFile,
return maxBz;
}
-bool FM1DMagnetoStatic::readFileHeader(std::ifstream &fieldFile) {
+bool _FM1DMagnetoStatic::readFileHeader(std::ifstream &fieldFile) {
std::string tempString;
int tempInt;
@@ -263,7 +265,7 @@ bool FM1DMagnetoStatic::readFileHeader(std::ifstream &fieldFile) {
tempString = Util::toUpper(tempString);
if (tempString != "TRUE" &&
tempString != "FALSE")
- throw GeneralClassicException("FM1DMagnetoStatic::readFileHeader",
+ throw GeneralClassicException("_FM1DMagnetoStatic::readFileHeader",
"The third string on the first line of 1D field "
"maps has to be either TRUE or FALSE");
@@ -285,11 +287,11 @@ bool FM1DMagnetoStatic::readFileHeader(std::ifstream &fieldFile) {
return parsingPassed;
}
-void FM1DMagnetoStatic::stripFileHeader(std::ifstream &fieldFile) {
+void _FM1DMagnetoStatic::stripFileHeader(std::ifstream &fieldFile) {
std::string tempString;
getLine(fieldFile, tempString);
getLine(fieldFile, tempString);
getLine(fieldFile, tempString);
-}
\ No newline at end of file
+}
diff --git a/src/Classic/Fields/FM1DMagnetoStatic.h b/src/Classic/Fields/FM1DMagnetoStatic.h
index 8873f279db92ae77b3f3472ef176121bae92fbe7..896645083cbc146c2628e66045da38ec90365de6 100644
--- a/src/Classic/Fields/FM1DMagnetoStatic.h
+++ b/src/Classic/Fields/FM1DMagnetoStatic.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class FM1DMagnetoStatic: public Fieldmap {
+class _FM1DMagnetoStatic: public _Fieldmap {
public:
+ virtual ~_FM1DMagnetoStatic();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
virtual void getFieldDimensions(double &xIni, double &xFinal,
@@ -20,8 +22,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- FM1DMagnetoStatic(std::string aFilename);
- ~FM1DMagnetoStatic();
+ _FM1DMagnetoStatic(const std::string& filename);
+
+ static FM1DMagnetoStatic create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -47,12 +50,14 @@ private:
int accuracy_m; /// Number of Fourier coefficients to use reconstructing field.
std::vector<double> fourierCoefs_m; /// Fourier coefficients derived from field map.
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool FM1DMagnetoStatic::isInside(const Vector_t &r) const
+inline bool _FM1DMagnetoStatic::isInside(const Vector_t &r) const
{
return r(2) >= zBegin_m && r(2) < zEnd_m;
}
-#endif
+using FM1DMagnetoStatic = std::shared_ptr<_FM1DMagnetoStatic>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM1DMagnetoStatic_fast.cpp b/src/Classic/Fields/FM1DMagnetoStatic_fast.cpp
index a3bc45846db9768268b538a53036ebef4e5637f6..ef98c972ee4c259ea41632ac9d70213bdd4170f0 100644
--- a/src/Classic/Fields/FM1DMagnetoStatic_fast.cpp
+++ b/src/Classic/Fields/FM1DMagnetoStatic_fast.cpp
@@ -10,8 +10,8 @@
#include <fstream>
#include <ios>
-FM1DMagnetoStatic_fast::FM1DMagnetoStatic_fast(std::string aFilename):
- Fieldmap(aFilename) {
+_FM1DMagnetoStatic_fast::_FM1DMagnetoStatic_fast(const std::string& filename):
+ _Fieldmap(filename) {
Type = T1DMagnetoStatic;
onAxisField_m = nullptr;
@@ -39,11 +39,16 @@ FM1DMagnetoStatic_fast::FM1DMagnetoStatic_fast(std::string aFilename):
}
}
-FM1DMagnetoStatic_fast::~FM1DMagnetoStatic_fast() {
+_FM1DMagnetoStatic_fast::~_FM1DMagnetoStatic_fast() {
freeMap();
}
-void FM1DMagnetoStatic_fast::readMap() {
+FM1DMagnetoStatic_fast _FM1DMagnetoStatic_fast::create(const std::string& filename)
+{
+ return FM1DMagnetoStatic_fast(new _FM1DMagnetoStatic_fast(filename));
+}
+
+void _FM1DMagnetoStatic_fast::readMap() {
if(onAxisField_m == nullptr) {
@@ -77,7 +82,7 @@ void FM1DMagnetoStatic_fast::readMap() {
}
}
-void FM1DMagnetoStatic_fast::freeMap() {
+void _FM1DMagnetoStatic_fast::freeMap() {
if(onAxisField_m != nullptr) {
delete [] onAxisField_m;
onAxisField_m = nullptr;
@@ -90,13 +95,10 @@ void FM1DMagnetoStatic_fast::freeMap() {
gsl_interp_accel_free(onAxisFieldPAccel_m);
gsl_interp_accel_free(onAxisFieldPPAccel_m);
gsl_interp_accel_free(onAxisFieldPPPAccel_m);
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info")
- << endl);
}
}
-bool FM1DMagnetoStatic_fast::getFieldstrength(const Vector_t &R, Vector_t &E,
+bool _FM1DMagnetoStatic_fast::getFieldstrength(const Vector_t &R, Vector_t &E,
Vector_t &B) const {
std::vector<double> fieldComponents;
@@ -107,7 +109,7 @@ bool FM1DMagnetoStatic_fast::getFieldstrength(const Vector_t &R, Vector_t &E,
}
-bool FM1DMagnetoStatic_fast::getFieldDerivative(const Vector_t &R,
+bool _FM1DMagnetoStatic_fast::getFieldDerivative(const Vector_t &R,
Vector_t &/*E*/,
Vector_t &B,
const DiffDirection &/*dir*/) const {
@@ -119,33 +121,33 @@ bool FM1DMagnetoStatic_fast::getFieldDerivative(const Vector_t &R,
}
-void FM1DMagnetoStatic_fast::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _FM1DMagnetoStatic_fast::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zBegin_m;
zEnd = zEnd_m;
}
-void FM1DMagnetoStatic_fast::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/,
+void _FM1DMagnetoStatic_fast::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/,
double &/*yIni*/, double &/*yFinal*/,
double &/*zIni*/, double &/*zFinal*/) const {}
-void FM1DMagnetoStatic_fast::swap()
+void _FM1DMagnetoStatic_fast::swap()
{ }
-void FM1DMagnetoStatic_fast::getInfo(Inform *msg) {
+void _FM1DMagnetoStatic_fast::getInfo(Inform *msg) {
(*msg) << Filename_m
<< " (1D magnetostatic); zini= "
<< zBegin_m << " m; zfinal= "
<< zEnd_m << " m;" << endl;
}
-double FM1DMagnetoStatic_fast::getFrequency() const {
+double _FM1DMagnetoStatic_fast::getFrequency() const {
return 0.0;
}
-void FM1DMagnetoStatic_fast::setFrequency(double /*freq*/)
+void _FM1DMagnetoStatic_fast::setFrequency(double /*freq*/)
{ }
-bool FM1DMagnetoStatic_fast::checkFileData(std::ifstream &fieldFile,
+bool _FM1DMagnetoStatic_fast::checkFileData(std::ifstream &fieldFile,
bool parsingPassed) {
double tempDouble;
@@ -157,7 +159,7 @@ bool FM1DMagnetoStatic_fast::checkFileData(std::ifstream &fieldFile,
}
-void FM1DMagnetoStatic_fast::computeFieldDerivatives(std::vector<double> fourierCoefs,
+void _FM1DMagnetoStatic_fast::computeFieldDerivatives(std::vector<double> fourierCoefs,
double onAxisFieldP[],
double onAxisFieldPP[],
double onAxisFieldPPP[]) {
@@ -192,7 +194,7 @@ void FM1DMagnetoStatic_fast::computeFieldDerivatives(std::vector<double> fourier
}
}
-void FM1DMagnetoStatic_fast::computeFieldOffAxis(const Vector_t &R,
+void _FM1DMagnetoStatic_fast::computeFieldOffAxis(const Vector_t &R,
Vector_t &/*E*/,
Vector_t &B,
std::vector<double> fieldComponents) const {
@@ -207,7 +209,7 @@ void FM1DMagnetoStatic_fast::computeFieldOffAxis(const Vector_t &R,
}
-void FM1DMagnetoStatic_fast::computeFieldOnAxis(double z,
+void _FM1DMagnetoStatic_fast::computeFieldOnAxis(double z,
std::vector<double> &fieldComponents) const {
fieldComponents.push_back(gsl_spline_eval(onAxisFieldInterpolants_m,
@@ -220,7 +222,7 @@ void FM1DMagnetoStatic_fast::computeFieldOnAxis(double z,
z, onAxisFieldPPPAccel_m));
}
-std::vector<double> FM1DMagnetoStatic_fast::computeFourierCoefficients(double fieldData[]) {
+std::vector<double> _FM1DMagnetoStatic_fast::computeFourierCoefficients(double fieldData[]) {
const unsigned int totalSize = 2 * numberOfGridPoints_m - 1;
gsl_fft_real_wavetable *waveTable = gsl_fft_real_wavetable_alloc(totalSize);
@@ -251,7 +253,7 @@ std::vector<double> FM1DMagnetoStatic_fast::computeFourierCoefficients(double fi
}
-void FM1DMagnetoStatic_fast::computeInterpolationVectors(double onAxisFieldP[],
+void _FM1DMagnetoStatic_fast::computeInterpolationVectors(double onAxisFieldP[],
double onAxisFieldPP[],
double onAxisFieldPPP[]) {
@@ -285,7 +287,7 @@ void FM1DMagnetoStatic_fast::computeInterpolationVectors(double onAxisFieldP[],
delete [] z;
}
-void FM1DMagnetoStatic_fast::convertHeaderData() {
+void _FM1DMagnetoStatic_fast::convertHeaderData() {
// Convert to m.
rBegin_m *= Units::cm2m;
@@ -294,7 +296,7 @@ void FM1DMagnetoStatic_fast::convertHeaderData() {
zEnd_m *= Units::cm2m;
}
-void FM1DMagnetoStatic_fast::normalizeField(double maxBz, std::vector<double> &fourierCoefs) {
+void _FM1DMagnetoStatic_fast::normalizeField(double maxBz, std::vector<double> &fourierCoefs) {
if (!normalize_m) return;
for (unsigned int dataIndex = 0; dataIndex < numberOfGridPoints_m; ++ dataIndex)
@@ -306,7 +308,7 @@ void FM1DMagnetoStatic_fast::normalizeField(double maxBz, std::vector<double> &f
}
-double FM1DMagnetoStatic_fast::readFileData(std::ifstream &fieldFile,
+double _FM1DMagnetoStatic_fast::readFileData(std::ifstream &fieldFile,
double fieldData[]) {
double maxBz = 0.0;
@@ -319,7 +321,7 @@ double FM1DMagnetoStatic_fast::readFileData(std::ifstream &fieldFile,
return maxBz;
}
-bool FM1DMagnetoStatic_fast::readFileHeader(std::ifstream &fieldFile) {
+bool _FM1DMagnetoStatic_fast::readFileHeader(std::ifstream &fieldFile) {
std::string tempString;
int tempInt;
@@ -339,7 +341,7 @@ bool FM1DMagnetoStatic_fast::readFileHeader(std::ifstream &fieldFile) {
tempString = Util::toUpper(tempString);
if (tempString != "TRUE" &&
tempString != "FALSE")
- throw GeneralClassicException("FM1DMagnetoStatic_fast::readFileHeader",
+ throw GeneralClassicException("_FM1DMagnetoStatic_fast::readFileHeader",
"The third string on the first line of 1D field "
"maps has to be either TRUE or FALSE");
@@ -365,7 +367,7 @@ bool FM1DMagnetoStatic_fast::readFileHeader(std::ifstream &fieldFile) {
return parsingPassed;
}
-void FM1DMagnetoStatic_fast::stripFileHeader(std::ifstream &fieldFile) {
+void _FM1DMagnetoStatic_fast::stripFileHeader(std::ifstream &fieldFile) {
std::string tempString;
@@ -374,7 +376,7 @@ void FM1DMagnetoStatic_fast::stripFileHeader(std::ifstream &fieldFile) {
getLine(fieldFile, tempString);
}
-void FM1DMagnetoStatic_fast::prepareForMapCheck(std::vector<double> &fourierCoefs) {
+void _FM1DMagnetoStatic_fast::prepareForMapCheck(std::vector<double> &fourierCoefs) {
std::vector<double> zSampling(numberOfGridPoints_m);
for (unsigned int zStepIndex = 0; zStepIndex < numberOfGridPoints_m; ++ zStepIndex)
zSampling[zStepIndex] = deltaZ_m * zStepIndex;
diff --git a/src/Classic/Fields/FM1DMagnetoStatic_fast.h b/src/Classic/Fields/FM1DMagnetoStatic_fast.h
index 431481c008ec0d86f559dd4919aeabfcddaeb742..118a0dd2953274d7f0b9eae22def69a2699b8f4b 100644
--- a/src/Classic/Fields/FM1DMagnetoStatic_fast.h
+++ b/src/Classic/Fields/FM1DMagnetoStatic_fast.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class FM1DMagnetoStatic_fast: public Fieldmap {
+class _FM1DMagnetoStatic_fast: public _Fieldmap {
public:
+ virtual ~_FM1DMagnetoStatic_fast();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
virtual void getFieldDimensions(double &xIni, double &xFinal,
@@ -20,8 +22,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- FM1DMagnetoStatic_fast(std::string aFilename);
- ~FM1DMagnetoStatic_fast();
+ _FM1DMagnetoStatic_fast(const std::string& filename);
+
+ static FM1DMagnetoStatic_fast create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -68,12 +71,14 @@ private:
gsl_interp_accel *onAxisFieldPPAccel_m;
gsl_interp_accel *onAxisFieldPPPAccel_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool FM1DMagnetoStatic_fast::isInside(const Vector_t &r) const
+inline bool _FM1DMagnetoStatic_fast::isInside(const Vector_t &r) const
{
return r(2) >= zBegin_m && r(2) < zEnd_m;
}
-#endif
+using FM1DMagnetoStatic_fast = std::shared_ptr<_FM1DMagnetoStatic_fast>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM1DProfile1.cpp b/src/Classic/Fields/FM1DProfile1.cpp
index 2e388b5bee355b3f091b7ffb19d104ab6983a023..1f4955bf7c4d2cbf6d0b0baba3719ac3928d528a 100644
--- a/src/Classic/Fields/FM1DProfile1.cpp
+++ b/src/Classic/Fields/FM1DProfile1.cpp
@@ -7,8 +7,8 @@
#include <fstream>
#include <ios>
-FM1DProfile1::FM1DProfile1(std::string aFilename):
- Fieldmap(aFilename),
+_FM1DProfile1::_FM1DProfile1(const std::string& filename):
+ _Fieldmap(filename),
entranceParameter1_m(0.0),
entranceParameter2_m(0.0),
entranceParameter3_m(0.0),
@@ -123,10 +123,15 @@ FM1DProfile1::FM1DProfile1(std::string aFilename):
}
}
-FM1DProfile1::~FM1DProfile1() {
+_FM1DProfile1::~_FM1DProfile1() {
}
-void FM1DProfile1::readMap() {
+FM1DProfile1 _FM1DProfile1::create(const std::string& filename)
+{
+ return FM1DProfile1(new _FM1DProfile1(filename));
+}
+
+void _FM1DProfile1::readMap() {
if(!engeCoeffsEntry_m.empty())
engeCoeffsEntry_m.clear();
@@ -206,10 +211,10 @@ void FM1DProfile1::readMap() {
}
}
-void FM1DProfile1::freeMap() {
+void _FM1DProfile1::freeMap() {
}
-bool FM1DProfile1::getFieldstrength(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/) const {
+bool _FM1DProfile1::getFieldstrength(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/) const {
/*
* For this type of field map, the elements who use it calculate the field
@@ -219,19 +224,19 @@ bool FM1DProfile1::getFieldstrength(const Vector_t &/*R*/, Vector_t &/*E*/, Vect
}
-bool FM1DProfile1::getFieldDerivative(const Vector_t &/*R*/,
+bool _FM1DProfile1::getFieldDerivative(const Vector_t &/*R*/,
Vector_t &/*E*/,
Vector_t &/*B*/,
const DiffDirection &/*dir*/) const {
return false;
}
-void FM1DProfile1::getFieldDimensions(double &sBegin,
+void _FM1DProfile1::getFieldDimensions(double &sBegin,
double &sEnd) const {
sBegin = sBegin_m;
sEnd = sEnd_m;
}
-void FM1DProfile1::getFieldDimensions(double &/*xIni*/,
+void _FM1DProfile1::getFieldDimensions(double &/*xIni*/,
double &/*xFinal*/,
double &/*yIni*/,
double &/*yFinal*/,
@@ -240,30 +245,30 @@ void FM1DProfile1::getFieldDimensions(double &/*xIni*/,
}
-void FM1DProfile1::swap()
+void _FM1DProfile1::swap()
{}
-void FM1DProfile1::getInfo(Inform *msg) {
+void _FM1DProfile1::getInfo(Inform *msg) {
(*msg) << Filename_m
<< " (1D Profile type 1)"
<< endl;
}
-double FM1DProfile1::getFrequency() const {
+double _FM1DProfile1::getFrequency() const {
return 0.0;
}
-void FM1DProfile1::setFrequency(double /*freq*/)
+void _FM1DProfile1::setFrequency(double /*freq*/)
{}
-void FM1DProfile1::get1DProfile1EngeCoeffs(std::vector<double> &engeCoeffsEntry,
+void _FM1DProfile1::get1DProfile1EngeCoeffs(std::vector<double> &engeCoeffsEntry,
std::vector<double> &engeCoeffsExit) {
engeCoeffsEntry = engeCoeffsEntry_m;
engeCoeffsExit = engeCoeffsExit_m;
}
-void FM1DProfile1::get1DProfile1EntranceParam(double &entranceParameter1,
+void _FM1DProfile1::get1DProfile1EntranceParam(double &entranceParameter1,
double &entranceParameter2,
double &entranceParameter3) {
entranceParameter1 = entranceParameter1_m;
@@ -271,7 +276,7 @@ void FM1DProfile1::get1DProfile1EntranceParam(double &entranceParameter1,
entranceParameter3 = entranceParameter3_m;
}
-void FM1DProfile1::get1DProfile1ExitParam(double &exitParameter1,
+void _FM1DProfile1::get1DProfile1ExitParam(double &exitParameter1,
double &exitParameter2,
double &exitParameter3) {
exitParameter1 = exitParameter1_m;
@@ -279,24 +284,24 @@ void FM1DProfile1::get1DProfile1ExitParam(double &exitParameter1,
exitParameter3 = exitParameter3_m;
}
-double FM1DProfile1::getFieldGap() {
+double _FM1DProfile1::getFieldGap() {
return gapHeight_m;
}
-void FM1DProfile1::setFieldGap(double gap) {
+void _FM1DProfile1::setFieldGap(double gap) {
gapHeight_m = gap;
}
-double FM1DProfile1::computeEntranceFringe(double z) const {
+double _FM1DProfile1::computeEntranceFringe(double z) const {
return computeFringe(engeCoeffsEntry_m, z / gapHeight_m);
}
-double FM1DProfile1::computeExitFringe(double z) const {
+double _FM1DProfile1::computeExitFringe(double z) const {
return computeFringe(engeCoeffsExit_m, z / gapHeight_m);
}
-double FM1DProfile1::computeFringe(const std::vector<double> &coefs, double z) const {
+double _FM1DProfile1::computeFringe(const std::vector<double> &coefs, double z) const {
const size_t N = coefs.size();
double expSum = coefs.at(0);
@@ -306,4 +311,4 @@ double FM1DProfile1::computeFringe(const std::vector<double> &coefs, double z) c
}
return 1.0 / (1.0 + exp(expSum));
-}
+}
\ No newline at end of file
diff --git a/src/Classic/Fields/FM1DProfile1.h b/src/Classic/Fields/FM1DProfile1.h
index c92484e2b6566da48b7543026e073571c3b3c39b..10a48b8cf3023a4d9c360eefa0554f2084e3a379 100644
--- a/src/Classic/Fields/FM1DProfile1.h
+++ b/src/Classic/Fields/FM1DProfile1.h
@@ -11,9 +11,10 @@
* Class FM1DProfile1 defines a 1D field map for us in bending magnets.
*/
-class FM1DProfile1: public Fieldmap {
+class _FM1DProfile1: public _Fieldmap {
public:
+ virtual ~_FM1DProfile1();
virtual bool getFieldDerivative(const Vector_t &X,
Vector_t &E,
@@ -49,9 +50,9 @@ public:
private:
/// Constructor with field map file name.
- FM1DProfile1(std::string Filename);
+ _FM1DProfile1(const std::string& filename);
- virtual ~FM1DProfile1();
+ static FM1DProfile1 create(const std::string& filename);
virtual void freeMap();
virtual void readMap();
@@ -84,7 +85,9 @@ private:
double sBegin_m; /// Start of field map in s coordinates (m).
double sEnd_m; /// End of field map in s coordinates (m).
- friend class Fieldmap;
+ friend class _Fieldmap;
};
+using FM1DProfile1 = std::shared_ptr<_FM1DProfile1>;
+
#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM1DProfile2.cpp b/src/Classic/Fields/FM1DProfile2.cpp
index 839e2a7dd94ce709b5145cd53e7bb2bc66206dab..f293b158750cc97e92473c5488fdd936135b6181 100644
--- a/src/Classic/Fields/FM1DProfile2.cpp
+++ b/src/Classic/Fields/FM1DProfile2.cpp
@@ -7,8 +7,8 @@
#include <ios>
#include <cmath>
-FM1DProfile2::FM1DProfile2(std::string aFilename)
- : Fieldmap(aFilename),
+_FM1DProfile2::_FM1DProfile2(const std::string& filename)
+ : _Fieldmap(filename),
EngeCoefs_entry_m(nullptr),
EngeCoefs_exit_m(nullptr),
exit_slope_m(0.0),
@@ -80,14 +80,19 @@ FM1DProfile2::FM1DProfile2(std::string aFilename)
}
}
-FM1DProfile2::~FM1DProfile2() {
+_FM1DProfile2::~_FM1DProfile2() {
if (EngeCoefs_entry_m != nullptr) {
delete[] EngeCoefs_entry_m;
delete[] EngeCoefs_exit_m;
}
}
-void FM1DProfile2::readMap() {
+FM1DProfile2 _FM1DProfile2::create(const std::string& filename)
+{
+ return FM1DProfile2(new _FM1DProfile2(filename));
+}
+
+void _FM1DProfile2::readMap() {
if (EngeCoefs_entry_m == nullptr) {
double tolerance = 1e-8;
@@ -192,19 +197,15 @@ void FM1DProfile2::readMap() {
}
}
-void FM1DProfile2::freeMap() {
+void _FM1DProfile2::freeMap() {
if (EngeCoefs_entry_m != nullptr) {
delete[] EngeCoefs_entry_m;
delete[] EngeCoefs_exit_m;
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info") << "\n"
- << endl);
-
}
}
-bool FM1DProfile2::getFieldstrength(const Vector_t &R, Vector_t &strength, Vector_t &info) const {
+bool _FM1DProfile2::getFieldstrength(const Vector_t &R, Vector_t &strength, Vector_t &info) const {
info = Vector_t(0.0);
@@ -323,35 +324,35 @@ bool FM1DProfile2::getFieldstrength(const Vector_t &R, Vector_t &strength, Vecto
}
-bool FM1DProfile2::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
+bool _FM1DProfile2::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
return false;
}
-void FM1DProfile2::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _FM1DProfile2::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zbegin_entry_m;
zEnd = zend_exit_m;
}
-void FM1DProfile2::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
+void _FM1DProfile2::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
-void FM1DProfile2::swap()
+void _FM1DProfile2::swap()
{}
-void FM1DProfile2::getInfo(Inform *msg) {
+void _FM1DProfile2::getInfo(Inform *msg) {
(*msg) << Filename_m << " (1D Profile type 2); zini= " << zbegin_entry_m << " m; zfinal= " << zend_exit_m << " m;" << endl;
}
-double FM1DProfile2::getFrequency() const {
+double _FM1DProfile2::getFrequency() const {
return 0.0;
}
-void FM1DProfile2::setFrequency(double /*freq*/)
+void _FM1DProfile2::setFrequency(double /*freq*/)
{}
-void FM1DProfile2::setExitFaceSlope(const double &m) {
+void _FM1DProfile2::setExitFaceSlope(const double &m) {
exit_slope_m = m;
}
-void FM1DProfile2::setEdgeConstants(const double &bendAngle, const double &entranceAngle, const double &exitAngle) {
+void _FM1DProfile2::setEdgeConstants(const double &bendAngle, const double &entranceAngle, const double &exitAngle) {
double deltaZ = polynomialOrigin_exit_m - polynomialOrigin_entry_m;
diff --git a/src/Classic/Fields/FM1DProfile2.h b/src/Classic/Fields/FM1DProfile2.h
index 11cb508bfc0d09b5136c70963593a25405f1f23a..a399f93052e47cd6cb56c8628a95629365249c25 100644
--- a/src/Classic/Fields/FM1DProfile2.h
+++ b/src/Classic/Fields/FM1DProfile2.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class FM1DProfile2: public Fieldmap {
+class _FM1DProfile2: public _Fieldmap {
public:
+ virtual ~_FM1DProfile2();
+
virtual bool getFieldstrength(const Vector_t &X, Vector_t &strength, Vector_t &info) const;
virtual bool getFieldDerivative(const Vector_t &X, Vector_t &E, Vector_t &B, const DiffDirection &dir) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
@@ -18,8 +20,9 @@ public:
virtual void setEdgeConstants(const double &bendAngle, const double &entranceAngle, const double &exitAngle);
private:
- FM1DProfile2(std::string aFilename);
- ~FM1DProfile2();
+ _FM1DProfile2(const std::string& filename);
+
+ static FM1DProfile2 create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -55,11 +58,13 @@ private:
double cosExitRotation_m;
double sinExitRotation_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
namespace QRDecomposition {
void solve(double *Matrix, double *Solution, double *rightHandSide, const int &M, const int &N);
}
-#endif
+using FM1DProfile2 = std::shared_ptr<_FM1DProfile2>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM2DDynamic.cpp b/src/Classic/Fields/FM2DDynamic.cpp
index 167180cbba366802cc3e6190cd5756bde092e1d3..6fe4a60c41db170e3ae47ed1fba42ba1d3ace3b7 100644
--- a/src/Classic/Fields/FM2DDynamic.cpp
+++ b/src/Classic/Fields/FM2DDynamic.cpp
@@ -10,8 +10,8 @@
#include <cmath>
-FM2DDynamic::FM2DDynamic(std::string aFilename)
- : Fieldmap(aFilename),
+_FM2DDynamic::_FM2DDynamic(const std::string& filename)
+ : _Fieldmap(filename),
FieldstrengthEz_m(nullptr),
FieldstrengthEr_m(nullptr),
FieldstrengthBt_m(nullptr) {
@@ -33,7 +33,7 @@ FM2DDynamic::FM2DDynamic(std::string aFilename)
tmpString = Util::toUpper(tmpString);
if (tmpString != "TRUE" &&
tmpString != "FALSE")
- throw GeneralClassicException("FM2DDynamic::FM2DDynamic",
+ throw GeneralClassicException("_FM2DDynamic::_FM2DDynamic",
"The third string on the first line of 2D field "
"maps has to be either TRUE or FALSE");
@@ -76,7 +76,7 @@ FM2DDynamic::FM2DDynamic(std::string aFilename)
if(!parsing_passed) {
disableFieldmapWarning();
zend_m = zbegin_m - 1e-3;
- throw GeneralClassicException("FM2DDynamic::FM2DDynamic",
+ throw GeneralClassicException("_FM2DDynamic::_FM2DDynamic",
"An error occured when reading the fieldmap '" + Filename_m + "'");
} else {
// convert MHz to Hz and frequency to angular frequency
@@ -103,11 +103,16 @@ FM2DDynamic::FM2DDynamic(std::string aFilename)
}
-FM2DDynamic::~FM2DDynamic() {
+_FM2DDynamic::~_FM2DDynamic() {
freeMap();
}
-void FM2DDynamic::readMap() {
+FM2DDynamic _FM2DDynamic::create(const std::string& filename)
+{
+ return FM2DDynamic(new _FM2DDynamic(filename));
+}
+
+void _FM2DDynamic::readMap() {
if(FieldstrengthEz_m == nullptr) {
// declare variables and allocate memory
std::ifstream in;
@@ -172,7 +177,7 @@ void FM2DDynamic::readMap() {
}
}
-void FM2DDynamic::freeMap() {
+void _FM2DDynamic::freeMap() {
if(FieldstrengthEz_m != nullptr) {
delete[] FieldstrengthEz_m;
FieldstrengthEz_m = nullptr;
@@ -180,13 +185,10 @@ void FM2DDynamic::freeMap() {
FieldstrengthEr_m = nullptr;
delete[] FieldstrengthBt_m;
FieldstrengthBt_m = nullptr;
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info") << "\n"
- << endl);
}
}
-bool FM2DDynamic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const {
+bool _FM2DDynamic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const {
// do bi-linear interpolation
const double RR = std::sqrt(R(0) * R(0) + R(1) * R(1));
@@ -230,34 +232,34 @@ bool FM2DDynamic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B)
return false;
}
-bool FM2DDynamic::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
+bool _FM2DDynamic::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
return false;
}
-void FM2DDynamic::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _FM2DDynamic::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zbegin_m;
zEnd = zend_m;
}
-void FM2DDynamic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
+void _FM2DDynamic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
-void FM2DDynamic::swap() {
+void _FM2DDynamic::swap() {
if(swap_m) swap_m = false;
else swap_m = true;
}
-void FM2DDynamic::getInfo(Inform *msg) {
+void _FM2DDynamic::getInfo(Inform *msg) {
(*msg) << Filename_m << " (2D dynamic); zini= " << zbegin_m << " m; zfinal= " << zend_m << " m;" << endl;
}
-double FM2DDynamic::getFrequency() const {
+double _FM2DDynamic::getFrequency() const {
return frequency_m;
}
-void FM2DDynamic::setFrequency(double freq) {
+void _FM2DDynamic::setFrequency(double freq) {
frequency_m = freq;
}
-void FM2DDynamic::getOnaxisEz(std::vector<std::pair<double, double> > & F) {
+void _FM2DDynamic::getOnaxisEz(std::vector<std::pair<double, double> > & F) {
double dz = (zend_m - zbegin_m) / (num_gridpz_m - 1);
F.resize(num_gridpz_m);
diff --git a/src/Classic/Fields/FM2DDynamic.h b/src/Classic/Fields/FM2DDynamic.h
index 5d53aa707db35127dad3a00fb5031e948983a0c1..8c36afe045532ae248d3620b88e3f1044048378b 100644
--- a/src/Classic/Fields/FM2DDynamic.h
+++ b/src/Classic/Fields/FM2DDynamic.h
@@ -5,9 +5,11 @@
#include "gsl/gsl_spline.h"
#include "Fields/Fieldmap.h"
-class FM2DDynamic: public Fieldmap {
+class _FM2DDynamic: public _Fieldmap {
public:
+ virtual ~_FM2DDynamic();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
virtual void getFieldDimensions(double &xIni, double &xFinal, double &yIni, double &yFinal, double &zIni, double &zFinal) const;
@@ -20,8 +22,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- FM2DDynamic(std::string aFilename);
- ~FM2DDynamic();
+ _FM2DDynamic(const std::string& filename);
+
+ static FM2DDynamic create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -42,12 +45,14 @@ private:
int num_gridpz_m; /**< Read in number of points after 0(not counted here) in grid, z-direction*/
bool swap_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool FM2DDynamic::isInside(const Vector_t &r) const
+inline bool _FM2DDynamic::isInside(const Vector_t &r) const
{
return r(2) >= zbegin_m && r(2) < zend_m && std::sqrt(r(0)*r(0) + r(1)*r(1)) < rend_m;
}
+using FM2DDynamic = std::shared_ptr<_FM2DDynamic>;
+
#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM2DElectroStatic.cpp b/src/Classic/Fields/FM2DElectroStatic.cpp
index e040b75a12471661c09797b3c37594d8d97dd7dc..49868c3577c186a0e56132ccfbbcfa99149a1e50 100644
--- a/src/Classic/Fields/FM2DElectroStatic.cpp
+++ b/src/Classic/Fields/FM2DElectroStatic.cpp
@@ -8,8 +8,8 @@
#include <ios>
#include <cmath>
-FM2DElectroStatic::FM2DElectroStatic(std::string aFilename)
- : Fieldmap(aFilename),
+_FM2DElectroStatic::_FM2DElectroStatic(const std::string& filename)
+ : _Fieldmap(filename),
FieldstrengthEz_m(nullptr),
FieldstrengthEr_m(nullptr) {
std::ifstream file;
@@ -33,7 +33,7 @@ FM2DElectroStatic::FM2DElectroStatic(std::string aFilename)
tmpString = Util::toUpper(tmpString);
if (tmpString != "TRUE" &&
tmpString != "FALSE")
- throw GeneralClassicException("FM2DElectroStatic::FM2DElectroStatic",
+ throw GeneralClassicException("_FM2DElectroStatic::_FM2DElectroStatic",
"The third string on the first line of 2D field "
"maps has to be either TRUE or FALSE");
@@ -70,7 +70,7 @@ FM2DElectroStatic::FM2DElectroStatic(std::string aFilename)
if (!parsing_passed) {
disableFieldmapWarning();
zend_m = zbegin_m - 1e-3;
- throw GeneralClassicException("FM2DElectroStatic::FM2DElectroStatic",
+ throw GeneralClassicException("_FM2DElectroStatic::_FM2DElectroStatic",
"An error occured when reading the fieldmap '" + Filename_m + "'");
} else {
// conversion from cm to m
@@ -93,11 +93,16 @@ FM2DElectroStatic::FM2DElectroStatic(std::string aFilename)
}
}
-FM2DElectroStatic::~FM2DElectroStatic() {
+_FM2DElectroStatic::~_FM2DElectroStatic() {
freeMap();
}
-void FM2DElectroStatic::readMap() {
+FM2DElectroStatic _FM2DElectroStatic::create(const std::string& filename)
+{
+ return FM2DElectroStatic(new _FM2DElectroStatic(filename));
+}
+
+void _FM2DElectroStatic::readMap() {
if (FieldstrengthEz_m == nullptr) {
// declare variables and allocate memory
std::ifstream in;
@@ -153,19 +158,16 @@ void FM2DElectroStatic::readMap() {
}
}
-void FM2DElectroStatic::freeMap() {
+void _FM2DElectroStatic::freeMap() {
if (FieldstrengthEz_m != nullptr) {
delete[] FieldstrengthEz_m;
FieldstrengthEz_m = nullptr;
delete[] FieldstrengthEr_m;
FieldstrengthEr_m = nullptr;
-
- INFOMSG(typeset_msg("freed field map '" + Filename_m + "'", "info") << "\n"
- << endl)
}
}
-bool FM2DElectroStatic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &/*B*/) const {
+bool _FM2DElectroStatic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &/*B*/) const {
// do bi-linear interpolation
const double RR = std::sqrt(R(0) * R(0) + R(1) * R(1));
@@ -200,28 +202,28 @@ bool FM2DElectroStatic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_
return false;
}
-bool FM2DElectroStatic::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
+bool _FM2DElectroStatic::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
return false;
}
-void FM2DElectroStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _FM2DElectroStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zbegin_m;
zEnd = zend_m;
}
-void FM2DElectroStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
+void _FM2DElectroStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
-void FM2DElectroStatic::swap() {
+void _FM2DElectroStatic::swap() {
if (swap_m) swap_m = false;
else swap_m = true;
}
-void FM2DElectroStatic::getInfo(Inform *msg) {
+void _FM2DElectroStatic::getInfo(Inform *msg) {
(*msg) << Filename_m << " (2D electrostatic); zini= " << zbegin_m << " m; zfinal= " << zend_m << " m;" << endl;
}
-double FM2DElectroStatic::getFrequency() const {
+double _FM2DElectroStatic::getFrequency() const {
return 0.0;
}
-void FM2DElectroStatic::setFrequency(double /*freq*/)
+void _FM2DElectroStatic::setFrequency(double /*freq*/)
{ ;}
diff --git a/src/Classic/Fields/FM2DElectroStatic.h b/src/Classic/Fields/FM2DElectroStatic.h
index bc7f4b5490258da61b28cb2e72acd2f5933f6d5b..69cfa6823598479afb8f09311111a1c9a357fe02 100644
--- a/src/Classic/Fields/FM2DElectroStatic.h
+++ b/src/Classic/Fields/FM2DElectroStatic.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class FM2DElectroStatic: public Fieldmap {
+class _FM2DElectroStatic: public _Fieldmap {
public:
+ virtual ~_FM2DElectroStatic();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
virtual void getFieldDimensions(double &xIni, double &xFinal, double &yIni, double &yFinal, double &zIni, double &zFinal) const;
@@ -17,8 +19,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- FM2DElectroStatic(std::string aFilename);
- ~FM2DElectroStatic();
+ _FM2DElectroStatic(const std::string& filename);
+
+ static FM2DElectroStatic create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -36,12 +39,14 @@ private:
int num_gridpz_m; /**< Read in number of points after 0(not counted here) in grid, z-direction*/
bool swap_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool FM2DElectroStatic::isInside(const Vector_t &r) const
+inline bool _FM2DElectroStatic::isInside(const Vector_t &r) const
{
return r(2) >= zbegin_m && r(2) < zend_m && std::sqrt(r(0)*r(0) + r(1)*r(1)) < rend_m;
}
+using FM2DElectroStatic = std::shared_ptr<_FM2DElectroStatic>;
+
#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM2DMagnetoStatic.cpp b/src/Classic/Fields/FM2DMagnetoStatic.cpp
index 9fb6e2b0661541c4254078ef1962091a35cbc03c..9d31408c36b836c98aa7bd58662a614377a0ad81 100644
--- a/src/Classic/Fields/FM2DMagnetoStatic.cpp
+++ b/src/Classic/Fields/FM2DMagnetoStatic.cpp
@@ -8,8 +8,8 @@
#include <ios>
#include <cmath>
-FM2DMagnetoStatic::FM2DMagnetoStatic(std::string aFilename):
- Fieldmap(aFilename),
+_FM2DMagnetoStatic::_FM2DMagnetoStatic(const std::string& filename):
+ _Fieldmap(filename),
FieldstrengthBz_m(nullptr),
FieldstrengthBr_m(nullptr) {
std::ifstream file;
@@ -35,7 +35,7 @@ FM2DMagnetoStatic::FM2DMagnetoStatic(std::string aFilename):
tmpString = Util::toUpper(tmpString);
if (tmpString != "TRUE" &&
tmpString != "FALSE")
- throw GeneralClassicException("FM2DMagnetoStatic::FM2DMagnetoStatic",
+ throw GeneralClassicException("_FM2DMagnetoStatic::_FM2DMagnetoStatic",
"The third string on the first line of 2D field "
"maps has to be either TRUE or FALSE");
@@ -72,7 +72,7 @@ FM2DMagnetoStatic::FM2DMagnetoStatic(std::string aFilename):
if(!parsing_passed) {
disableFieldmapWarning();
zend_m = zbegin_m - 1e-3;
- throw GeneralClassicException("FM2DMagnetoStatic::FM2DMagnetoStatic",
+ throw GeneralClassicException("_FM2DMagnetoStatic::_FM2DMagnetoStatic",
"An error occured when reading the fieldmap '" + Filename_m + "'");
} else {
// conversion from cm to m
@@ -95,11 +95,16 @@ FM2DMagnetoStatic::FM2DMagnetoStatic(std::string aFilename):
}
}
-FM2DMagnetoStatic::~FM2DMagnetoStatic() {
+_FM2DMagnetoStatic::~_FM2DMagnetoStatic() {
freeMap();
}
-void FM2DMagnetoStatic::readMap() {
+FM2DMagnetoStatic _FM2DMagnetoStatic::create(const std::string& filename)
+{
+ return FM2DMagnetoStatic(new _FM2DMagnetoStatic(filename));
+}
+
+void _FM2DMagnetoStatic::readMap() {
if(FieldstrengthBz_m == nullptr) {
// declare variables and allocate memory
std::ifstream in;
@@ -153,19 +158,17 @@ void FM2DMagnetoStatic::readMap() {
}
}
-void FM2DMagnetoStatic::freeMap() {
+void _FM2DMagnetoStatic::freeMap() {
if(FieldstrengthBz_m != nullptr) {
delete[] FieldstrengthBz_m;
delete[] FieldstrengthBr_m;
FieldstrengthBz_m = nullptr;
FieldstrengthBr_m = nullptr;
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info") << endl);
}
}
-bool FM2DMagnetoStatic::getFieldstrength(const Vector_t &R, Vector_t &/*E*/, Vector_t &B) const {
+bool _FM2DMagnetoStatic::getFieldstrength(const Vector_t &R, Vector_t &/*E*/, Vector_t &B) const {
// do bi-linear interpolation
const double RR = std::sqrt(R(0) * R(0) + R(1) * R(1));
@@ -201,7 +204,7 @@ bool FM2DMagnetoStatic::getFieldstrength(const Vector_t &R, Vector_t &/*E*/, Vec
return false;
}
-bool FM2DMagnetoStatic::getFieldDerivative(const Vector_t &R, Vector_t &/*E*/, Vector_t &B, const DiffDirection &dir) const {
+bool _FM2DMagnetoStatic::getFieldDerivative(const Vector_t &R, Vector_t &/*E*/, Vector_t &B, const DiffDirection &dir) const {
double BfieldR, BfieldZ;
@@ -303,25 +306,25 @@ bool FM2DMagnetoStatic::getFieldDerivative(const Vector_t &R, Vector_t &/*E*/, V
return false;
}
-void FM2DMagnetoStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _FM2DMagnetoStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zbegin_m;
zEnd = zend_m;
}
-void FM2DMagnetoStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
+void _FM2DMagnetoStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
-void FM2DMagnetoStatic::swap() {
+void _FM2DMagnetoStatic::swap() {
if(swap_m) swap_m = false;
else swap_m = true;
}
-void FM2DMagnetoStatic::getInfo(Inform *msg) {
+void _FM2DMagnetoStatic::getInfo(Inform *msg) {
(*msg) << Filename_m << " (2D magnetostatic); zini= " << zbegin_m << " m; zfinal= " << zend_m << " m;" << endl;
}
-double FM2DMagnetoStatic::getFrequency() const {
+double _FM2DMagnetoStatic::getFrequency() const {
return 0.0;
}
-void FM2DMagnetoStatic::setFrequency(double /*freq*/)
+void _FM2DMagnetoStatic::setFrequency(double /*freq*/)
{ ;}
diff --git a/src/Classic/Fields/FM2DMagnetoStatic.h b/src/Classic/Fields/FM2DMagnetoStatic.h
index b87db9325867761e9cf3420c522bb68690205d05..e61f45fcfc72d083e538eab5a13b6251e4826963 100644
--- a/src/Classic/Fields/FM2DMagnetoStatic.h
+++ b/src/Classic/Fields/FM2DMagnetoStatic.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class FM2DMagnetoStatic: public Fieldmap {
+class _FM2DMagnetoStatic: public _Fieldmap {
public:
+ virtual ~_FM2DMagnetoStatic();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual bool getFieldDerivative(const Vector_t &R, Vector_t &E, Vector_t &B, const DiffDirection &dir) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
@@ -17,8 +19,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- FM2DMagnetoStatic(std::string aFilename);
- ~FM2DMagnetoStatic();
+ _FM2DMagnetoStatic(const std::string& filename);
+
+ static FM2DMagnetoStatic create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -36,12 +39,14 @@ private:
int num_gridpz_m; /**< Read in number of points after 0(not counted here) in grid, z-direction*/
bool swap_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool FM2DMagnetoStatic::isInside(const Vector_t &r) const
+inline bool _FM2DMagnetoStatic::isInside(const Vector_t &r) const
{
return r(2) >= zbegin_m && r(2) < zend_m && std::sqrt(r(0)*r(0) + r(1)*r(1)) < rend_m;
}
+using FM2DMagnetoStatic = std::shared_ptr<_FM2DMagnetoStatic>;
+
#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM3DDynamic.cpp b/src/Classic/Fields/FM3DDynamic.cpp
index 279bb2c79c4625f5457f90dd58c76bd250ec299f..2dcb5f28f80f3c5f397c57e811cfa35438b3b4cf 100644
--- a/src/Classic/Fields/FM3DDynamic.cpp
+++ b/src/Classic/Fields/FM3DDynamic.cpp
@@ -12,8 +12,8 @@
#include <ios>
-FM3DDynamic::FM3DDynamic(std::string aFilename):
- Fieldmap(aFilename),
+_FM3DDynamic::_FM3DDynamic(const std::string& filename):
+ _Fieldmap(filename),
FieldstrengthEz_m(nullptr),
FieldstrengthEx_m(nullptr),
FieldstrengthEy_m(nullptr),
@@ -38,7 +38,7 @@ FM3DDynamic::FM3DDynamic(std::string aFilename):
tmpString = Util::toUpper(tmpString);
if (tmpString != "TRUE" &&
tmpString != "FALSE")
- throw GeneralClassicException("FM3DDynamic::FM3DDynamic",
+ throw GeneralClassicException("_FM3DDynamic::_FM3DDynamic",
"The second string on the first line of 3D field "
"maps has to be either TRUE or FALSE");
@@ -73,7 +73,7 @@ FM3DDynamic::FM3DDynamic(std::string aFilename):
if(!parsing_passed) {
disableFieldmapWarning();
zend_m = zbegin_m - 1e-3;
- throw GeneralClassicException("FM3DDynamic::FM3DDynamic",
+ throw GeneralClassicException("_FM3DDynamic::_FM3DDynamic",
"An error occured when reading the fieldmap '" + Filename_m + "'");
} else {
frequency_m *= Physics::two_pi * Units::MHz2Hz;
@@ -102,11 +102,16 @@ FM3DDynamic::FM3DDynamic(std::string aFilename):
}
-FM3DDynamic::~FM3DDynamic() {
+_FM3DDynamic::~_FM3DDynamic() {
freeMap();
}
-void FM3DDynamic::readMap() {
+FM3DDynamic _FM3DDynamic::create(const std::string& filename)
+{
+ return FM3DDynamic(new _FM3DDynamic(filename));
+}
+
+void _FM3DDynamic::readMap() {
if(FieldstrengthEz_m == nullptr) {
std::ifstream in(Filename_m.c_str());
@@ -217,7 +222,7 @@ void FM3DDynamic::readMap() {
}
}
-void FM3DDynamic::freeMap() {
+void _FM3DDynamic::freeMap() {
if(FieldstrengthEz_m != nullptr) {
delete[] FieldstrengthEz_m;
delete[] FieldstrengthEx_m;
@@ -232,13 +237,10 @@ void FM3DDynamic::freeMap() {
FieldstrengthBz_m = nullptr;
FieldstrengthBx_m = nullptr;
FieldstrengthBy_m = nullptr;
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info") << "\n"
- << endl);
}
}
-bool FM3DDynamic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const {
+bool _FM3DDynamic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const {
const unsigned int index_x = static_cast<int>(std::floor((R(0) - xbegin_m) / hx_m));
const double lever_x = (R(0) - xbegin_m) / hx_m - index_x;
@@ -318,34 +320,34 @@ bool FM3DDynamic::getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B)
return false;
}
-bool FM3DDynamic::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
+bool _FM3DDynamic::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
return false;
}
-void FM3DDynamic::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _FM3DDynamic::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zbegin_m;
zEnd = zend_m;
}
-void FM3DDynamic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
+void _FM3DDynamic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
-void FM3DDynamic::swap() {}
+void _FM3DDynamic::swap() {}
-void FM3DDynamic::getInfo(Inform *msg) {
+void _FM3DDynamic::getInfo(Inform *msg) {
(*msg) << Filename_m << " (3D dynamic) "
<< " xini= " << xbegin_m << " xfinal= " << xend_m
<< " yini= " << ybegin_m << " yfinal= " << yend_m
<< " zini= " << zbegin_m << " zfinal= " << zend_m << " (m) " << endl;
}
-double FM3DDynamic::getFrequency() const {
+double _FM3DDynamic::getFrequency() const {
return frequency_m;
}
-void FM3DDynamic::setFrequency(double freq) {
+void _FM3DDynamic::setFrequency(double freq) {
frequency_m = freq;
}
-void FM3DDynamic::getOnaxisEz(std::vector<std::pair<double, double> > & F) {
+void _FM3DDynamic::getOnaxisEz(std::vector<std::pair<double, double> > & F) {
F.resize(num_gridpz_m);
int index_x = static_cast<int>(ceil(-xbegin_m / hx_m));
diff --git a/src/Classic/Fields/FM3DDynamic.h b/src/Classic/Fields/FM3DDynamic.h
index f5ab1575e28bd3668c6e261f36d206c16d8fff61..7b90c2316119920ec07f884032a483d1585846cb 100644
--- a/src/Classic/Fields/FM3DDynamic.h
+++ b/src/Classic/Fields/FM3DDynamic.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class FM3DDynamic: public Fieldmap {
+class _FM3DDynamic: public _Fieldmap {
public:
+ virtual ~_FM3DDynamic();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
virtual void getFieldDimensions(double &xIni, double &xFinal, double &yIni, double &yFinal, double &zIni, double &zFinal) const;
@@ -18,8 +20,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- FM3DDynamic(std::string aFilename);
- ~FM3DDynamic();
+ _FM3DDynamic(const std::string& filename);
+
+ static FM3DDynamic create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -50,14 +53,16 @@ private:
unsigned int num_gridpz_m; /**< Read in number of points after 0(not counted here) in grid, z-direction*/
bool normalize_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-inline bool FM3DDynamic::isInside(const Vector_t &r) const
+inline bool _FM3DDynamic::isInside(const Vector_t &r) const
{
return ((r(0) >= xbegin_m && r(0) < xend_m) &&
(r(1) >= ybegin_m && r(1) < yend_m) &&
(r(2) >= zbegin_m && r(2) < zend_m));
}
+using FM3DDynamic = std::shared_ptr<_FM3DDynamic>;
+
#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM3DH5Block.cpp b/src/Classic/Fields/FM3DH5Block.cpp
index daa99860816b956fa494ca8f8ecef68126de510c..bd6a8897f62947c9c231abc20c6705bcc9c5f261 100644
--- a/src/Classic/Fields/FM3DH5Block.cpp
+++ b/src/Classic/Fields/FM3DH5Block.cpp
@@ -1,5 +1,5 @@
//
-// Class FM3DH5Block
+// Class _FM3DH5Block
// Class for dynamic 3D field-maps stored in H5hut files.
//
// Copyright (c) 2020, Achim Gsell, Paul Scherrer Institut, Villigen PSI, Switzerland
@@ -18,25 +18,30 @@
#include "Fields/FM3DH5Block.h"
-FM3DH5Block::FM3DH5Block (
- std::string aFilename
- ) : Fieldmap (
- aFilename
+_FM3DH5Block::_FM3DH5Block (
+ const std::string& filename
+ ) : _Fieldmap(
+ filename
) {
Type = T3DDynamicH5Block;
- openFileMPIOCollective (aFilename);
+ openFileMPIOCollective (filename);
getFieldInfo ("Efield");
getResonanceFrequency ();
closeFile ();
}
-FM3DH5Block::~FM3DH5Block (
+_FM3DH5Block::~_FM3DH5Block (
) {
freeMap ();
}
-void FM3DH5Block::readMap (
+FM3DH5Block _FM3DH5Block::create(const std::string& filename)
+{
+ return FM3DH5Block(new _FM3DH5Block(filename));
+}
+
+void _FM3DH5Block::readMap (
) {
if (!FieldstrengthEz_m.empty()) {
return;
@@ -71,7 +76,7 @@ void FM3DH5Block::readMap (
<< endl);
}
-void FM3DH5Block::freeMap (
+void _FM3DH5Block::freeMap (
) {
if(FieldstrengthEz_m.empty ()) {
return;
@@ -82,13 +87,9 @@ void FM3DH5Block::freeMap (
FieldstrengthHx_m.clear ();
FieldstrengthHy_m.clear ();
FieldstrengthHz_m.clear ();
-
- INFOMSG (level3
- << typeset_msg ("freed fieldmap '" + Filename_m + "'", "info")
- << endl);
}
-bool FM3DH5Block::getFieldstrength (
+bool _FM3DH5Block::getFieldstrength (
const Vector_t& R,
Vector_t& E,
Vector_t& B
diff --git a/src/Classic/Fields/FM3DH5Block.h b/src/Classic/Fields/FM3DH5Block.h
index 366402aa86e68194412d1abd04dcea24eb462182..4b57c904dfe5303101bb11d94363e8542f3929a2 100644
--- a/src/Classic/Fields/FM3DH5Block.h
+++ b/src/Classic/Fields/FM3DH5Block.h
@@ -23,19 +23,21 @@
#include <vector>
-class FM3DH5Block: public FM3DH5BlockBase {
+class _FM3DH5Block: public _FM3DH5BlockBase {
public:
virtual bool getFieldstrength (
const Vector_t &R, Vector_t &E, Vector_t &B) const;
-
-private:
- FM3DH5Block (
- std::string aFilename);
- virtual ~FM3DH5Block (
+ virtual ~_FM3DH5Block (
);
+private:
+ _FM3DH5Block (
+ const std::string& filename);
+
+ static FM3DH5Block create(const std::string& filename);
+
virtual void readMap (
);
@@ -46,8 +48,10 @@ private:
std::vector<double> FieldstrengthHx_m; /**< 3D array with Hx */
std::vector<double> FieldstrengthHy_m; /**< 3D array with Hy */
- friend class Fieldmap;
- friend class FM3DH5BlockBase;
+ friend class _Fieldmap;
+ friend class _FM3DH5BlockBase;
};
-#endif
+using FM3DH5Block = std::shared_ptr<_FM3DH5Block>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM3DH5BlockBase.cpp b/src/Classic/Fields/FM3DH5BlockBase.cpp
index 3f0aa0549a20aae12c18fbe9ef44ca728fc6c527..6ef68ffda6f2a901309c7a2eefbe234206960694 100644
--- a/src/Classic/Fields/FM3DH5BlockBase.cpp
+++ b/src/Classic/Fields/FM3DH5BlockBase.cpp
@@ -21,51 +21,51 @@
#include "Physics/Physics.h"
#include "Utilities/GeneralClassicException.h"
-void FM3DH5BlockBase::openFileMPIOCollective (
- const std::string aFilename
+void _FM3DH5BlockBase::openFileMPIOCollective (
+ const std::string& filename
) {
h5_prop_t props = H5CreateFileProp ();
MPI_Comm comm = Ippl::getComm();
if (H5SetPropFileMPIOCollective (props, &comm) == H5_ERR) {
throw GeneralClassicException (
- "FM3DH5BlockBase::openFileMPIOCollective () ",
+ "_FM3DH5BlockBase::openFileMPIOCollective () ",
"Cannot set MPIO collective!");
}
- file_m = H5OpenFile (aFilename.c_str(), H5_O_RDONLY, props);
+ file_m = H5OpenFile (filename.c_str(), H5_O_RDONLY, props);
if (file_m == (h5_file_t)H5_ERR) {
throw GeneralClassicException (
- "FM3DH5BlockBase::openFileMPIOCollective () ",
- "Cannot open file '" + aFilename + "'!");
+ "_FM3DH5BlockBase::openFileMPIOCollective () ",
+ "Cannot open file '" + filename + "'!");
}
H5CloseProp (props);
}
-long long FM3DH5BlockBase::getNumSteps (void) {
+long long _FM3DH5BlockBase::getNumSteps (void) {
long long num_steps = H5GetNumSteps(file_m);
if (num_steps <= 0) {
if (num_steps == 0) {
throw GeneralClassicException (
- "FM3DH5BlockBase::getNumSteps () ",
+ "_FM3DH5BlockBase::getNumSteps () ",
"Number of time-steps in file '" + Filename_m + "' is zero!");
} else {
throw GeneralClassicException (
- "FM3DH5BlockBase::getNumSteps () ",
+ "_FM3DH5BlockBase::getNumSteps () ",
"Query number of time-steps in file '" + Filename_m + "' failed!");
}
}
return num_steps;
}
-void FM3DH5BlockBase::setStep (long long step) {
+void _FM3DH5BlockBase::setStep (long long step) {
if (H5SetStep(file_m, step) == H5_ERR) {
throw GeneralClassicException (
- "FM3DH5BlockBase::setStep () ",
+ "_FM3DH5BlockBase::setStep () ",
"Cannot set time-step to " + std::to_string (step) +
" in file '" + Filename_m + "'!");
}
}
-
-void FM3DH5BlockBase::getFieldInfo (const char* name) {
+
+void _FM3DH5BlockBase::getFieldInfo (const char* name) {
long long last_step = getNumSteps () - 1;
setStep (last_step);
h5_size_t grid_rank;
@@ -77,7 +77,7 @@ void FM3DH5BlockBase::getFieldInfo (const char* name) {
&grid_rank, grid_dims, &field_dims, &ftype
) == H5_ERR) {
throw GeneralClassicException (
- "FM3DH5BlockBase::GetFieldInfo () ",
+ "_FM3DH5BlockBase::GetFieldInfo () ",
"Query of field info for " + std::string (name) +
" in time-step " + std::to_string (last_step) +
" in file '" + Filename_m + "' failed!");
@@ -90,16 +90,16 @@ void FM3DH5BlockBase::getFieldInfo (const char* name) {
file_m, "Efield", &hx_m, &hy_m, &hz_m
) == H5_ERR) {
throw GeneralClassicException (
- "FM3DH5BlockBase::GetFieldInfo () ",
+ "_FM3DH5BlockBase::GetFieldInfo () ",
"Query of field spacing"
" in time-step " + std::to_string (last_step) +
" in file '" + Filename_m + "' failed!");
}
-
+
if (H5Block3dGetFieldOrigin(
file_m, "Efield", &xbegin_m, &ybegin_m, &zbegin_m) == H5_ERR) {
throw GeneralClassicException (
- "FM3DH5BlockBase::GetFieldInfo () ",
+ "_FM3DH5BlockBase::GetFieldInfo () ",
"Query of field origin"
" in time-step " + std::to_string (last_step) +
" in file '" + Filename_m + "' failed!");
@@ -109,19 +109,19 @@ void FM3DH5BlockBase::getFieldInfo (const char* name) {
zend_m = zbegin_m + (num_gridpz_m - 1) * hz_m;
}
-void FM3DH5BlockBase::getResonanceFrequency (void) {
+void _FM3DH5BlockBase::getResonanceFrequency (void) {
if (H5ReadFileAttribFloat64 (
file_m, "Resonance Frequency(Hz)", &frequency_m
) == H5_ERR) {
throw GeneralClassicException (
- "FM3DH5BlockBase::GetResonanceFrequency () ",
+ "_FM3DH5BlockBase::GetResonanceFrequency () ",
"Cannot read file attribute 'Resonance Frequency(Hz)'"
" in file '" + Filename_m + "'!");
}
frequency_m *= Physics::two_pi;
}
-void FM3DH5BlockBase::readField (
+void _FM3DH5BlockBase::readField (
const char* name,
double* x,
double* y,
@@ -132,7 +132,7 @@ void FM3DH5BlockBase::readField (
0, num_gridpy_m - 1,
0, num_gridpz_m - 1) == H5_ERR) {
throw GeneralClassicException (
- "FM3DH5BlockBase::ReadField () ",
+ "_FM3DH5BlockBase::ReadField () ",
"Cannot set view "
"0, " + std::to_string (num_gridpx_m) +
"0, " + std::to_string (num_gridpy_m) +
@@ -144,21 +144,21 @@ void FM3DH5BlockBase::readField (
name,
x, y, z) == H5_ERR) {
throw GeneralClassicException (
- "FM3DH5BlockBase::ReadField () ",
+ "_FM3DH5BlockBase::ReadField () ",
"Cannot read field " + std::string (name) +
" in file '" + Filename_m + "'!");
}
}
-void FM3DH5BlockBase::closeFile (void) {
+void _FM3DH5BlockBase::closeFile (void) {
if (H5CloseFile (file_m) == H5_ERR) {
throw GeneralClassicException (
- "FM3DH5BlockBase::closeFile () ",
+ "_FM3DH5BlockBase::closeFile () ",
"Error closing file '" + Filename_m + "'!");
}
}
-double FM3DH5BlockBase::getWeightedData (
+double _FM3DH5BlockBase::getWeightedData (
const std::vector<double>& data,
const IndexTriplet& idx,
unsigned short corner
@@ -175,7 +175,7 @@ double FM3DH5BlockBase::getWeightedData (
return factorX * factorY * factorZ * data[getIndex(i, j, k)];
}
-Vector_t FM3DH5BlockBase::interpolateTrilinearly (
+Vector_t _FM3DH5BlockBase::interpolateTrilinearly (
const std::vector<double>& field_strength_x,
const std::vector<double>& field_strength_y,
const std::vector<double>& field_strength_z,
@@ -214,7 +214,7 @@ Vector_t FM3DH5BlockBase::interpolateTrilinearly (
return result;
}
-void FM3DH5BlockBase::getInfo (Inform* msg) {
+void _FM3DH5BlockBase::getInfo (Inform* msg) {
(*msg) << Filename_m << " (3D dynamic) "
<< " xini= " << xbegin_m << " xfinal= " << xend_m
<< " yini= " << ybegin_m << " yfinal= " << yend_m
@@ -222,15 +222,15 @@ void FM3DH5BlockBase::getInfo (Inform* msg) {
(*msg) << " hx= " << hx_m <<" hy= " << hy_m <<" hz= " << hz_m << " [mm] " <<endl;
}
-double FM3DH5BlockBase::getFrequency () const {
+double _FM3DH5BlockBase::getFrequency () const {
return frequency_m;
}
-void FM3DH5BlockBase::setFrequency (double freq) {
+void _FM3DH5BlockBase::setFrequency (double freq) {
frequency_m = freq;
}
-void FM3DH5BlockBase::getOnaxisEz (
+void _FM3DH5BlockBase::getOnaxisEz (
std::vector<std::pair<double, double>>& F
) {
F.resize(num_gridpz_m);
@@ -259,4 +259,4 @@ void FM3DH5BlockBase::getOnaxisEz (
}
F[i].second /= Ez_max;
}
-}
+}
\ No newline at end of file
diff --git a/src/Classic/Fields/FM3DH5BlockBase.h b/src/Classic/Fields/FM3DH5BlockBase.h
index 5ed65bab1a2e2a1f87c05b0d8cdde081abcf8f39..9cfd90f8312805a5bf038dd1e6623de1d3c8fdb3 100644
--- a/src/Classic/Fields/FM3DH5BlockBase.h
+++ b/src/Classic/Fields/FM3DH5BlockBase.h
@@ -28,7 +28,7 @@ static_assert (sizeof(double) == sizeof (h5_float64_t),
static_assert (sizeof(long long) == sizeof (h5_int64_t),
"long long and h5_int64_t are not the same type" );
-class FM3DH5BlockBase: virtual public Fieldmap {
+class _FM3DH5BlockBase: virtual public _Fieldmap {
public:
virtual void readMap (
@@ -71,7 +71,7 @@ public:
virtual void swap(
) {};
-
+
virtual void getInfo (
Inform *msg);
@@ -85,14 +85,14 @@ public:
std::vector<std::pair<double, double> >& F);
protected:
- FM3DH5BlockBase (
+ _FM3DH5BlockBase (
) {};
- virtual ~FM3DH5BlockBase (
+ virtual ~_FM3DH5BlockBase (
) {};
void openFileMPIOCollective (
- const std::string aFilename);
+ const std::string& filename);
long long getNumSteps (
void);
@@ -115,7 +115,7 @@ protected:
void closeFile (
void);
-
+
virtual bool isInside (
const Vector_t &r
) const {
@@ -151,7 +151,7 @@ protected:
) const {
unsigned long result = j + k * num_gridpy_m;
result = i + result * num_gridpx_m;
-
+
return result;
}
@@ -194,7 +194,7 @@ protected:
std::vector<double> FieldstrengthEz_m; /**< 3D array with Ez */
std::vector<double> FieldstrengthEx_m; /**< 3D array with Ex */
std::vector<double> FieldstrengthEy_m; /**< 3D array with Ey */
-
+
double xbegin_m;
double xend_m;
@@ -215,7 +215,9 @@ protected:
double frequency_m;
bool swap_m;
- friend class Fieldmap;
+ friend class _Fieldmap;
};
-#endif
+using FM3DH5BlockBase = std::shared_ptr<_FM3DH5BlockBase>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM3DH5Block_nonscale.cpp b/src/Classic/Fields/FM3DH5Block_nonscale.cpp
index 0f1beba199a0d2e3f4b78182e4ef726c9bdb571c..fc7e538b124432c4c24a6ce65f8d017f4394e67a 100644
--- a/src/Classic/Fields/FM3DH5Block_nonscale.cpp
+++ b/src/Classic/Fields/FM3DH5Block_nonscale.cpp
@@ -21,26 +21,31 @@
#include "Physics/Units.h"
#include "Utilities/GeneralClassicException.h"
-FM3DH5Block_nonscale::FM3DH5Block_nonscale (
- std::string aFilename
- ) : Fieldmap (
- aFilename),
- FM3DH5BlockBase (
+_FM3DH5Block_nonscale::_FM3DH5Block_nonscale (
+ const std::string& filename
+ ) : _Fieldmap (
+ filename),
+ _FM3DH5BlockBase (
) {
Type = T3DDynamicH5Block;
- openFileMPIOCollective (aFilename);
+ openFileMPIOCollective (filename);
getFieldInfo ("Efield");
getResonanceFrequency ();
closeFile ();
}
-FM3DH5Block_nonscale::~FM3DH5Block_nonscale (
+_FM3DH5Block_nonscale::~_FM3DH5Block_nonscale (
) {
freeMap();
}
-void FM3DH5Block_nonscale::readMap (
+FM3DH5Block_nonscale _FM3DH5Block_nonscale::create(const std::string& filename)
+{
+ return FM3DH5Block_nonscale(new _FM3DH5Block_nonscale(filename));
+}
+
+void _FM3DH5Block_nonscale::readMap (
) {
if (!FieldstrengthEz_m.empty()) {
return;
@@ -84,7 +89,7 @@ void FM3DH5Block_nonscale::readMap (
<< endl);
}
-void FM3DH5Block_nonscale::freeMap (
+void _FM3DH5Block_nonscale::freeMap (
) {
if(FieldstrengthEz_m.empty ()) {
return;
@@ -95,12 +100,9 @@ void FM3DH5Block_nonscale::freeMap (
FieldstrengthHx_m.clear ();
FieldstrengthHy_m.clear ();
FieldstrengthHz_m.clear ();
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info")
- << endl);
}
-bool FM3DH5Block_nonscale::getFieldstrength (
+bool _FM3DH5Block_nonscale::getFieldstrength (
const Vector_t& R,
Vector_t& E,
Vector_t& B
@@ -114,4 +116,4 @@ bool FM3DH5Block_nonscale::getFieldstrength (
FieldstrengthHx_m, FieldstrengthHy_m, FieldstrengthHz_m, R);
return false;
-}
\ No newline at end of file
+}
diff --git a/src/Classic/Fields/FM3DH5Block_nonscale.h b/src/Classic/Fields/FM3DH5Block_nonscale.h
index 2f771484b706ae1bd580917fcfe27b1c68118eab..7f203c552e01e3754d735569fbf83e2afa0ccc52 100644
--- a/src/Classic/Fields/FM3DH5Block_nonscale.h
+++ b/src/Classic/Fields/FM3DH5Block_nonscale.h
@@ -23,19 +23,21 @@
#include <vector>
-class FM3DH5Block_nonscale: public FM3DH5BlockBase {
+class _FM3DH5Block_nonscale: public _FM3DH5BlockBase {
public:
virtual bool getFieldstrength (
const Vector_t &R, Vector_t &E, Vector_t &B) const;
-
-private:
- FM3DH5Block_nonscale (
- std::string aFilename);
- virtual ~FM3DH5Block_nonscale (
+ virtual ~_FM3DH5Block_nonscale (
);
+private:
+ _FM3DH5Block_nonscale (
+ const std::string& filename);
+
+ static FM3DH5Block_nonscale create(const std::string& filename);
+
virtual void readMap (
);
@@ -46,8 +48,10 @@ private:
std::vector<double> FieldstrengthHx_m; /**< 3D array with Hx */
std::vector<double> FieldstrengthHy_m; /**< 3D array with Hy */
- friend class Fieldmap;
- friend class FM3DH5BlockBase;
+ friend class _Fieldmap;
+ friend class _FM3DH5BlockBase;
};
-#endif
+using FM3DH5Block_nonscale = std::shared_ptr<_FM3DH5Block_nonscale>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM3DMagnetoStatic.cpp b/src/Classic/Fields/FM3DMagnetoStatic.cpp
index 88aafc8ace5041d982f5ca9dc8bd3e733da20121..10c100ab0b29c8ab0256d91c162a6d17a1cb4207 100644
--- a/src/Classic/Fields/FM3DMagnetoStatic.cpp
+++ b/src/Classic/Fields/FM3DMagnetoStatic.cpp
@@ -9,8 +9,8 @@
#include <ios>
-FM3DMagnetoStatic::FM3DMagnetoStatic(std::string aFilename):
- Fieldmap(aFilename),
+_FM3DMagnetoStatic::_FM3DMagnetoStatic(const std::string& filename):
+ _Fieldmap(filename),
FieldstrengthBz_m(nullptr),
FieldstrengthBx_m(nullptr),
FieldstrengthBy_m(nullptr) {
@@ -31,7 +31,7 @@ FM3DMagnetoStatic::FM3DMagnetoStatic(std::string aFilename):
tmpString = Util::toUpper(tmpString);
if (tmpString != "TRUE" &&
tmpString != "FALSE")
- throw GeneralClassicException("FM3DMagnetoStatic::FM3DMagnetoStatic",
+ throw GeneralClassicException("_FM3DMagnetoStatic::_FM3DMagnetoStatic",
"The second string on the first line of 3D field "
"maps has to be either TRUE or FALSE");
@@ -59,7 +59,7 @@ FM3DMagnetoStatic::FM3DMagnetoStatic(std::string aFilename):
file.close();
if(!parsing_passed) {
- throw GeneralClassicException("FM3DMagnetoStatic::FM3DMagnetoStatic",
+ throw GeneralClassicException("_FM3DMagnetoStatic::_FM3DMagnetoStatic",
"An error occured when reading the fieldmap '" + Filename_m + "'");
} else {
xbegin_m *= Units::cm2m;
@@ -79,17 +79,22 @@ FM3DMagnetoStatic::FM3DMagnetoStatic(std::string aFilename):
}
} else {
- throw GeneralClassicException("FM3DMagnetoStatic::FM3DMagnetoStatic",
+ throw GeneralClassicException("_FM3DMagnetoStatic::_FM3DMagnetoStatic",
"An error occured when reading the fieldmap '" + Filename_m + "'");
}
}
-FM3DMagnetoStatic::~FM3DMagnetoStatic() {
+_FM3DMagnetoStatic::~_FM3DMagnetoStatic() {
freeMap();
}
-void FM3DMagnetoStatic::readMap() {
+FM3DMagnetoStatic _FM3DMagnetoStatic::create(const std::string& filename)
+{
+ return FM3DMagnetoStatic(new _FM3DMagnetoStatic(filename));
+}
+
+void _FM3DMagnetoStatic::readMap() {
if(FieldstrengthBz_m == nullptr) {
std::ifstream in(Filename_m.c_str());
@@ -144,7 +149,7 @@ void FM3DMagnetoStatic::readMap() {
}
}
-void FM3DMagnetoStatic::freeMap() {
+void _FM3DMagnetoStatic::freeMap() {
if(FieldstrengthBz_m != nullptr) {
delete[] FieldstrengthBz_m;
delete[] FieldstrengthBx_m;
@@ -153,13 +158,10 @@ void FM3DMagnetoStatic::freeMap() {
FieldstrengthBz_m = nullptr;
FieldstrengthBx_m = nullptr;
FieldstrengthBy_m = nullptr;
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info") << "\n"
- << endl);
}
}
-bool FM3DMagnetoStatic::getFieldstrength(const Vector_t &R, Vector_t &/*E*/, Vector_t &B) const {
+bool _FM3DMagnetoStatic::getFieldstrength(const Vector_t &R, Vector_t &/*E*/, Vector_t &B) const {
if (!isInside(R)) {
return true;
}
@@ -169,7 +171,7 @@ bool FM3DMagnetoStatic::getFieldstrength(const Vector_t &R, Vector_t &/*E*/, Vec
return false;
}
-Vector_t FM3DMagnetoStatic::interpolateTrilinearly(const Vector_t &X) const {
+Vector_t _FM3DMagnetoStatic::interpolateTrilinearly(const Vector_t &X) const {
IndexTriplet idx = getIndex(X);
Vector_t B(0.0);
@@ -203,7 +205,7 @@ Vector_t FM3DMagnetoStatic::interpolateTrilinearly(const Vector_t &X) const {
return B;
}
-double FM3DMagnetoStatic::getWeightedData(double *data, const IndexTriplet &idx, unsigned short corner) const {
+double _FM3DMagnetoStatic::getWeightedData(double *data, const IndexTriplet &idx, unsigned short corner) const {
unsigned short switchX = ((corner & HX) >> 2), switchY = ((corner & HY) >> 1), switchZ = (corner & HZ);
double factorX = 0.5 + (1 - 2 * switchX) * (0.5 - idx.weight(0));
double factorY = 0.5 + (1 - 2 * switchY) * (0.5 - idx.weight(1));
@@ -214,19 +216,19 @@ double FM3DMagnetoStatic::getWeightedData(double *data, const IndexTriplet &idx,
return factorX * factorY * factorZ * data[getIndex(i, j, k)];
}
-bool FM3DMagnetoStatic::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
+bool _FM3DMagnetoStatic::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
return false;
}
-void FM3DMagnetoStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _FM3DMagnetoStatic::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zbegin_m;
zEnd = zend_m;
}
-void FM3DMagnetoStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
+void _FM3DMagnetoStatic::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
-void FM3DMagnetoStatic::swap() {}
+void _FM3DMagnetoStatic::swap() {}
-void FM3DMagnetoStatic::getInfo(Inform *msg) {
+void _FM3DMagnetoStatic::getInfo(Inform *msg) {
(*msg) << Filename_m << " (3D magnetostatic) "
<< " xini= " << xbegin_m << " xfinal= " << xend_m
<< " yini= " << ybegin_m << " yfinal= " << yend_m
diff --git a/src/Classic/Fields/FM3DMagnetoStatic.h b/src/Classic/Fields/FM3DMagnetoStatic.h
index ac44d0cc7d5a9fd8c2e72f02474ec7a6fb384089..d695f043518f47cbf994a93828ec5f66fa9cad65 100644
--- a/src/Classic/Fields/FM3DMagnetoStatic.h
+++ b/src/Classic/Fields/FM3DMagnetoStatic.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class FM3DMagnetoStatic: public Fieldmap {
+class _FM3DMagnetoStatic: public _Fieldmap {
public:
+ virtual ~_FM3DMagnetoStatic();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
virtual void getFieldDimensions(double &xIni, double &xFinal, double &yIni, double &yFinal, double &zIni, double &zFinal) const;
@@ -17,8 +19,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- FM3DMagnetoStatic(std::string aFilename);
- ~FM3DMagnetoStatic();
+ _FM3DMagnetoStatic(const std::string& filename);
+
+ static FM3DMagnetoStatic create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -68,11 +71,11 @@ private:
unsigned int num_gridpy_m; /**< Read in number of points after 0(not counted here) in grid, r-direction*/
unsigned int num_gridpz_m; /**< Read in number of points after 0(not counted here) in grid, z-direction*/
- friend class Fieldmap;
+ friend class _Fieldmap;
};
inline
-bool FM3DMagnetoStatic::isInside(const Vector_t &r) const
+bool _FM3DMagnetoStatic::isInside(const Vector_t &r) const
{
return ((r(0) >= xbegin_m && r(0) < xend_m)
&& (r(1) >= ybegin_m && r(1) < yend_m)
@@ -80,15 +83,15 @@ bool FM3DMagnetoStatic::isInside(const Vector_t &r) const
}
inline
-double FM3DMagnetoStatic::getFrequency() const {
+double _FM3DMagnetoStatic::getFrequency() const {
return 0.0;
}
inline
-void FM3DMagnetoStatic::setFrequency(double /*freq*/) { }
+void _FM3DMagnetoStatic::setFrequency(double /*freq*/) { }
inline
-unsigned long FM3DMagnetoStatic::getIndex(unsigned int i, unsigned int j, unsigned int k) const
+unsigned long _FM3DMagnetoStatic::getIndex(unsigned int i, unsigned int j, unsigned int k) const
{
unsigned long result = i + j * num_gridpx_m;
result = k + result * num_gridpz_m;
@@ -97,7 +100,7 @@ unsigned long FM3DMagnetoStatic::getIndex(unsigned int i, unsigned int j, unsign
}
inline
-FM3DMagnetoStatic::IndexTriplet FM3DMagnetoStatic::getIndex(const Vector_t &X) const {
+_FM3DMagnetoStatic::IndexTriplet _FM3DMagnetoStatic::getIndex(const Vector_t &X) const {
IndexTriplet idx;
idx.i = std::floor((X(0) - xbegin_m) / hx_m);
idx.j = std::floor((X(1) - ybegin_m) / hy_m);
@@ -113,4 +116,6 @@ FM3DMagnetoStatic::IndexTriplet FM3DMagnetoStatic::getIndex(const Vector_t &X) c
return idx;
}
-#endif
+using FM3DMagnetoStatic = std::shared_ptr<_FM3DMagnetoStatic>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM3DMagnetoStaticExtended.cpp b/src/Classic/Fields/FM3DMagnetoStaticExtended.cpp
index 85c9fde1eab0217edffacc5382b577b4e3248025..a0fee6532c494d10c244cdc8ad8b57476ab9894a 100644
--- a/src/Classic/Fields/FM3DMagnetoStaticExtended.cpp
+++ b/src/Classic/Fields/FM3DMagnetoStaticExtended.cpp
@@ -11,8 +11,8 @@
extern Inform *gmsg;
-FM3DMagnetoStaticExtended::FM3DMagnetoStaticExtended(std::string aFilename):
- Fieldmap(aFilename),
+_FM3DMagnetoStaticExtended::_FM3DMagnetoStaticExtended(const std::string& filename):
+ _Fieldmap(filename),
FieldstrengthBx_m(nullptr),
FieldstrengthBy_m(nullptr),
FieldstrengthBz_m(nullptr) {
@@ -34,7 +34,7 @@ FM3DMagnetoStaticExtended::FM3DMagnetoStaticExtended(std::string aFilename):
tmpString = Util::toUpper(tmpString);
if (tmpString != "TRUE" &&
tmpString != "FALSE")
- throw GeneralClassicException("FM3DMagnetoStaticExtended::FM3DMagnetoStaticExtended",
+ throw GeneralClassicException("_FM3DMagnetoStaticExtended::_FM3DMagnetoStaticExtended",
"The second string on the first line of 3D field "
"maps has to be either TRUE or FALSE");
@@ -60,7 +60,7 @@ FM3DMagnetoStaticExtended::FM3DMagnetoStaticExtended(std::string aFilename):
if(!parsing_passed) {
disableFieldmapWarning();
zend_m = zbegin_m - 1e-3;
- throw GeneralClassicException("FM3DMagnetoStaticExtended::FM3DMagnetoStaticExtended(std::string)",
+ throw GeneralClassicException("_FM3DMagnetoStaticExtended::_FM3DMagnetoStaticExtended(std::string)",
"Format of fieldmap '" + Filename_m + "' didn't pass basic test");
} else {
// conversion from cm to m
@@ -82,16 +82,21 @@ FM3DMagnetoStaticExtended::FM3DMagnetoStaticExtended(std::string aFilename):
num_gridpz_m++;
}
} else {
- throw GeneralClassicException("FM3DMagnetoStaticExtended::FM3DMagnetoStaticExtended(std::string)",
+ throw GeneralClassicException("_FM3DMagnetoStaticExtended::_FM3DMagnetoStaticExtended(std::string)",
"Couldn't read fieldmap '" + Filename_m + "'");
}
}
-FM3DMagnetoStaticExtended::~FM3DMagnetoStaticExtended() {
+_FM3DMagnetoStaticExtended::~_FM3DMagnetoStaticExtended() {
freeMap();
}
-void FM3DMagnetoStaticExtended::readMap() {
+FM3DMagnetoStaticExtended _FM3DMagnetoStaticExtended::create(const std::string& filename)
+{
+ return FM3DMagnetoStaticExtended(new _FM3DMagnetoStaticExtended(filename));
+}
+
+void _FM3DMagnetoStaticExtended::readMap() {
if(FieldstrengthBz_m == nullptr) {
// declare variables and allocate memory
std::ifstream in;
@@ -155,7 +160,7 @@ void FM3DMagnetoStaticExtended::readMap() {
}
}
-void FM3DMagnetoStaticExtended::integrateBx(unsigned j) {
+void _FM3DMagnetoStaticExtended::integrateBx(unsigned j) {
if (j == 1) {
{
unsigned int i = 0;
@@ -222,7 +227,7 @@ void FM3DMagnetoStaticExtended::integrateBx(unsigned j) {
}
}
-void FM3DMagnetoStaticExtended::integrateBz(unsigned j) {
+void _FM3DMagnetoStaticExtended::integrateBz(unsigned j) {
if (j == 1) {
// treat cells at i = 0:num_gridpx_m - 1, j = 1, k = 1:num_gridpz_m - 2;
for(unsigned int i = 0; i < num_gridpx_m; i ++) {
@@ -280,7 +285,7 @@ void FM3DMagnetoStaticExtended::integrateBz(unsigned j) {
}
}
-void FM3DMagnetoStaticExtended::integrateBy(unsigned j) {
+void _FM3DMagnetoStaticExtended::integrateBy(unsigned j) {
if (j == 1) {
for (unsigned int i = 1; i < num_gridpx_m - 1; i ++) {
{ // treat cells at i = 1:num_gridpx_m - 2, j = 1, k = 0
@@ -497,7 +502,7 @@ void FM3DMagnetoStaticExtended::integrateBy(unsigned j) {
}
}
-void FM3DMagnetoStaticExtended::smoothData(double * data, unsigned j)
+void _FM3DMagnetoStaticExtended::smoothData(double * data, unsigned j)
{
const double offWeight = 0.1, sumWeightInv = 1.0 / (1.0 + 4 * (1 + offWeight) * offWeight);
double *tmp = new double[num_gridpx_m * num_gridpy_m * num_gridpz_m];
@@ -602,7 +607,7 @@ void FM3DMagnetoStaticExtended::smoothData(double * data, unsigned j)
delete[] tmp;
}
-void FM3DMagnetoStaticExtended::saveField(const std::string &fname, unsigned int j) const
+void _FM3DMagnetoStaticExtended::saveField(const std::string &fname, unsigned int j) const
{
std::ofstream out(fname);
out.precision(6);
@@ -624,7 +629,7 @@ void FM3DMagnetoStaticExtended::saveField(const std::string &fname, unsigned int
out.close();
}
-void FM3DMagnetoStaticExtended::freeMap() {
+void _FM3DMagnetoStaticExtended::freeMap() {
if(FieldstrengthBz_m != nullptr) {
delete[] FieldstrengthBx_m;
delete[] FieldstrengthBy_m;
@@ -633,12 +638,10 @@ void FM3DMagnetoStaticExtended::freeMap() {
FieldstrengthBx_m = nullptr;
FieldstrengthBy_m = nullptr;
FieldstrengthBz_m = nullptr;
-
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info") << endl);
}
}
-Vector_t FM3DMagnetoStaticExtended::interpolateTrilinearly(const Vector_t &X) const {
+Vector_t _FM3DMagnetoStaticExtended::interpolateTrilinearly(const Vector_t &X) const {
IndexTriplet idx = getIndex(X);
Vector_t B(0.0);
@@ -672,7 +675,7 @@ Vector_t FM3DMagnetoStaticExtended::interpolateTrilinearly(const Vector_t &X) co
return B;
}
-double FM3DMagnetoStaticExtended::getWeightedData(double *data, const IndexTriplet &idx, unsigned short corner) const {
+double _FM3DMagnetoStaticExtended::getWeightedData(double *data, const IndexTriplet &idx, unsigned short corner) const {
unsigned short switchX = ((corner & HX) >> 2), switchY = ((corner & HY) >> 1), switchZ = (corner & HZ);
double factorX = 0.5 + (1 - 2 * switchX) * (0.5 - idx.weight(0));
double factorY = 0.5 + (1 - 2 * switchY) * (0.5 - idx.weight(1));
@@ -683,7 +686,7 @@ double FM3DMagnetoStaticExtended::getWeightedData(double *data, const IndexTripl
return factorX * factorY * factorZ * data[getIndex(i, j, k)];
}
-bool FM3DMagnetoStaticExtended::getFieldstrength(const Vector_t &R, Vector_t &/*E*/, Vector_t &B) const {
+bool _FM3DMagnetoStaticExtended::getFieldstrength(const Vector_t &R, Vector_t &/*E*/, Vector_t &B) const {
if (isInside(R)) {
Vector_t suppB = interpolateTrilinearly(R);
suppB(0) *= copysign(1, R(1));
@@ -695,16 +698,16 @@ bool FM3DMagnetoStaticExtended::getFieldstrength(const Vector_t &R, Vector_t &/*
return false;
}
-bool FM3DMagnetoStaticExtended::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
+bool _FM3DMagnetoStaticExtended::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
return false;
}
-void FM3DMagnetoStaticExtended::getFieldDimensions(double &zBegin, double &zEnd) const {
+void _FM3DMagnetoStaticExtended::getFieldDimensions(double &zBegin, double &zEnd) const {
zBegin = zbegin_m;
zEnd = zend_m;
}
-void FM3DMagnetoStaticExtended::getFieldDimensions(double &xIni, double &xFinal, double &yIni, double &yFinal, double &zIni, double &zFinal) const {
+void _FM3DMagnetoStaticExtended::getFieldDimensions(double &xIni, double &xFinal, double &yIni, double &yFinal, double &zIni, double &zFinal) const {
xIni = xbegin_m;
xFinal = xend_m;
yIni = -yend_m;
@@ -713,16 +716,16 @@ void FM3DMagnetoStaticExtended::getFieldDimensions(double &xIni, double &xFinal,
zFinal = zend_m;
}
-void FM3DMagnetoStaticExtended::swap() {
+void _FM3DMagnetoStaticExtended::swap() {
}
-void FM3DMagnetoStaticExtended::getInfo(Inform *msg) {
+void _FM3DMagnetoStaticExtended::getInfo(Inform *msg) {
(*msg) << Filename_m << " (3D magnetostatic, extended); zini= " << zbegin_m << " m; zfinal= " << zend_m << " m;" << endl;
}
-double FM3DMagnetoStaticExtended::getFrequency() const {
+double _FM3DMagnetoStaticExtended::getFrequency() const {
return 0.0;
}
-void FM3DMagnetoStaticExtended::setFrequency(double /*freq*/)
+void _FM3DMagnetoStaticExtended::setFrequency(double /*freq*/)
{ ;}
diff --git a/src/Classic/Fields/FM3DMagnetoStaticExtended.h b/src/Classic/Fields/FM3DMagnetoStaticExtended.h
index 25b030cbd7a1cfbd3c1a63dfdde053d07ecb7fcb..16bdb137794354f87da94fd0e3eb3555758929d7 100644
--- a/src/Classic/Fields/FM3DMagnetoStaticExtended.h
+++ b/src/Classic/Fields/FM3DMagnetoStaticExtended.h
@@ -3,9 +3,11 @@
#include "Fields/Fieldmap.h"
-class FM3DMagnetoStaticExtended: public Fieldmap {
+class _FM3DMagnetoStaticExtended: public _Fieldmap {
public:
+ virtual ~_FM3DMagnetoStaticExtended();
+
virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
virtual bool getFieldDerivative(const Vector_t &R, Vector_t &E, Vector_t &B, const DiffDirection &dir) const;
virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
@@ -17,8 +19,9 @@ public:
virtual bool isInside(const Vector_t &r) const;
private:
- FM3DMagnetoStaticExtended(std::string aFilename);
- ~FM3DMagnetoStaticExtended();
+ _FM3DMagnetoStaticExtended(const std::string& filename);
+
+ static FM3DMagnetoStaticExtended create(const std::string& filename);
virtual void readMap();
virtual void freeMap();
@@ -74,17 +77,17 @@ private:
unsigned int num_gridpy_m; /**< Read in number of points after 0(not counted here) in grid, y-direction*/
unsigned int num_gridpz_m; /**< Read in number of points after 0(not counted here) in grid, z-direction*/
- friend class Fieldmap;
+ friend class _Fieldmap;
};
inline
-bool FM3DMagnetoStaticExtended::isInside(const Vector_t &r) const
+bool _FM3DMagnetoStaticExtended::isInside(const Vector_t &r) const
{
return r(2) >= 0.0 && r(2) < length_m && r(0) >= xbegin_m && r(0) < xend_m && std::abs(r(1)) < yend_m;
}
inline
-unsigned long FM3DMagnetoStaticExtended::getIndex(unsigned int i, unsigned int j, unsigned int k) const
+unsigned long _FM3DMagnetoStaticExtended::getIndex(unsigned int i, unsigned int j, unsigned int k) const
{
unsigned long result = i + j * num_gridpx_m;
result = k + result * num_gridpz_m;
@@ -93,7 +96,7 @@ unsigned long FM3DMagnetoStaticExtended::getIndex(unsigned int i, unsigned int j
}
inline
-FM3DMagnetoStaticExtended::IndexTriplet FM3DMagnetoStaticExtended::getIndex(const Vector_t &X) const {
+_FM3DMagnetoStaticExtended::IndexTriplet _FM3DMagnetoStaticExtended::getIndex(const Vector_t &X) const {
IndexTriplet idx;
idx.i = std::floor((X(0) - xbegin_m) / hx_m);
idx.j = std::floor(std::abs(X(1)) / hy_m);
@@ -109,4 +112,6 @@ FM3DMagnetoStaticExtended::IndexTriplet FM3DMagnetoStaticExtended::getIndex(cons
return idx;
}
-#endif
+using FM3DMagnetoStaticExtended = std::shared_ptr<_FM3DMagnetoStaticExtended>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FM3DMagnetoStaticH5Block.cpp b/src/Classic/Fields/FM3DMagnetoStaticH5Block.cpp
index 46112b6f53979fff5da4983bc851a09fcb224d6d..c3fcf6a10a4dc8935e8d157d015e270cdd8705a4 100644
--- a/src/Classic/Fields/FM3DMagnetoStaticH5Block.cpp
+++ b/src/Classic/Fields/FM3DMagnetoStaticH5Block.cpp
@@ -19,26 +19,27 @@
#include "Fields/FM3DMagnetoStaticH5Block.h"
#include "Utilities/GeneralClassicException.h"
-FM3DMagnetoStaticH5Block::FM3DMagnetoStaticH5Block (
- std::string aFilename
- ) : Fieldmap (
- aFilename),
- FM3DH5BlockBase (
- ) {
- Type = T3DMagnetoStaticH5Block;
+_FM3DMagnetoStaticH5Block::_FM3DMagnetoStaticH5Block (const std::string& filename)
+ : _Fieldmap(filename)
+ , _FM3DH5BlockBase () {
+ Type = T3DMagnetoStaticH5Block;
- openFileMPIOCollective (aFilename);
- getFieldInfo ("Efield");
- getResonanceFrequency ();
- closeFile ();
+ openFileMPIOCollective (filename);
+ getFieldInfo ("Efield");
+ getResonanceFrequency ();
+ closeFile ();
}
-FM3DMagnetoStaticH5Block::~FM3DMagnetoStaticH5Block (
- ) {
+_FM3DMagnetoStaticH5Block::~_FM3DMagnetoStaticH5Block () {
freeMap ();
}
-void FM3DMagnetoStaticH5Block::readMap (
+FM3DMagnetoStaticH5Block _FM3DMagnetoStaticH5Block::create(const std::string& filename)
+{
+ return FM3DMagnetoStaticH5Block(new _FM3DMagnetoStaticH5Block(filename));
+}
+
+void _FM3DMagnetoStaticH5Block::readMap (
) {
if (!FieldstrengthEz_m.empty()) {
return;
@@ -72,7 +73,7 @@ void FM3DMagnetoStaticH5Block::readMap (
+ Filename_m + "' (H5hut format) read", "info")
<< endl);
}
-void FM3DMagnetoStaticH5Block::freeMap (
+void _FM3DMagnetoStaticH5Block::freeMap (
) {
if(FieldstrengthEz_m.empty()) {
return;
@@ -83,11 +84,9 @@ void FM3DMagnetoStaticH5Block::freeMap (
FieldstrengthBx_m.clear();
FieldstrengthBy_m.clear();
FieldstrengthBz_m.clear();
- INFOMSG(level3 << typeset_msg("freed fieldmap '" + Filename_m + "'", "info")
- << endl);
}
-bool FM3DMagnetoStaticH5Block::getFieldstrength (
+bool _FM3DMagnetoStaticH5Block::getFieldstrength (
const Vector_t& R,
Vector_t& E,
Vector_t& B
@@ -103,7 +102,7 @@ bool FM3DMagnetoStaticH5Block::getFieldstrength (
return false;
}
-double FM3DMagnetoStaticH5Block::getFrequency (
+double _FM3DMagnetoStaticH5Block::getFrequency (
) const {
return 0.0;
}
diff --git a/src/Classic/Fields/FM3DMagnetoStaticH5Block.h b/src/Classic/Fields/FM3DMagnetoStaticH5Block.h
index 52e1afeec9e9b0de19b2ab85493fdfc033595ce2..4258a42f9c125f079c8e8b73b252bd7d7cb2eece 100644
--- a/src/Classic/Fields/FM3DMagnetoStaticH5Block.h
+++ b/src/Classic/Fields/FM3DMagnetoStaticH5Block.h
@@ -23,19 +23,21 @@
#include <vector>
-class FM3DMagnetoStaticH5Block: public FM3DH5BlockBase {
+class _FM3DMagnetoStaticH5Block: public _FM3DH5BlockBase {
public:
virtual bool getFieldstrength (
const Vector_t &R, Vector_t &E, Vector_t &B) const;
-
-private:
- FM3DMagnetoStaticH5Block (
- std::string aFilename);
- virtual ~FM3DMagnetoStaticH5Block (
+ virtual ~_FM3DMagnetoStaticH5Block (
);
+private:
+ _FM3DMagnetoStaticH5Block (
+ const std::string& filename);
+
+ static FM3DMagnetoStaticH5Block create(const std::string& filename);
+
virtual void readMap (
);
@@ -49,8 +51,10 @@ private:
std::vector<double> FieldstrengthBx_m; /**< 3D array with Bx */
std::vector<double> FieldstrengthBy_m; /**< 3D array with By */
- friend class Fieldmap;
- friend class FM3DH5BlockBase;
+ friend class _Fieldmap;
+ friend class _FM3DH5BlockBase;
};
-#endif
+using FM3DMagnetoStaticH5Block = std::shared_ptr<_FM3DMagnetoStaticH5Block>;
+
+#endif
\ No newline at end of file
diff --git a/src/Classic/Fields/FMDummy.cpp b/src/Classic/Fields/FMDummy.cpp
deleted file mode 100644
index 61691be702da96407c44efa67301b53ac18eb729..0000000000000000000000000000000000000000
--- a/src/Classic/Fields/FMDummy.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "Fields/FMDummy.h"
-#include "Fields/Fieldmap.hpp"
-
-
-FMDummy::FMDummy(std::string aFilename):
- Fieldmap(aFilename),
- zbegin_m(0.0),
- zend_m(-1e-3) {
-
- std::stringstream errormsg;
- errormsg << "THERE SEEMS TO BE SOMETHING WRONG WITH YOUR FIELD MAP '" << Filename_m << "'.\n"
- << "Could not determine the file type.\n"
- << "Please check the section about field maps in the user manual.\n";
- std::string errormsg_str = typeset_msg(errormsg.str(), "error");
- WARNMSG(errormsg_str << "\n" << endl);
-
- if(Ippl::myNode() == 0) {
- std::ofstream omsg("errormsg.txt", std::ios_base::app);
- omsg << errormsg_str << std::endl;
- omsg.close();
- }
- disableFieldmapWarning();
-}
-
-FMDummy::~FMDummy()
-{ }
-
-void FMDummy::readMap()
-{ }
-
-void FMDummy::freeMap()
-{ }
-
-bool FMDummy::getFieldstrength(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/) const {
- return false;
-}
-
-bool FMDummy::getFieldDerivative(const Vector_t &/*R*/, Vector_t &/*E*/, Vector_t &/*B*/, const DiffDirection &/*dir*/) const {
- return false;
-}
-
-void FMDummy::getFieldDimensions(double &zBegin, double &zEnd) const {
- zBegin = zbegin_m;
- zEnd = zend_m;
-}
-void FMDummy::getFieldDimensions(double &/*xIni*/, double &/*xFinal*/, double &/*yIni*/, double &/*yFinal*/, double &/*zIni*/, double &/*zFinal*/) const {}
-
-void FMDummy::swap()
-{ }
-
-void FMDummy::getInfo(Inform */*msg*/)
-{ }
-
-double FMDummy::getFrequency() const {
- static double dummy = 0.0;
- return dummy;
-}
-
-void FMDummy::setFrequency(double /*freq*/)
-{ }
diff --git a/src/Classic/Fields/FMDummy.h b/src/Classic/Fields/FMDummy.h
deleted file mode 100644
index 79f40793fa4026a935c61a22c7f364572f82afbd..0000000000000000000000000000000000000000
--- a/src/Classic/Fields/FMDummy.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef CLASSIC_FIELDMAPDUMMY
-#define CLASSIC_FIELDMAPDUMMY
-
-#include "Fields/Fieldmap.h"
-
-class FMDummy: public Fieldmap {
-
-public:
- virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
- virtual bool getFieldDerivative(const Vector_t &R, Vector_t &E, Vector_t &B, const DiffDirection &dir) const;
- virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
- virtual void getFieldDimensions(double &xIni, double &xFinal, double &yIni, double &yFinal, double &zIni, double &zFinal) const;
- virtual void swap();
- virtual void getInfo(Inform *);
- virtual double getFrequency() const;
- virtual void setFrequency(double freq);
-
-private:
- FMDummy(std::string aFilename);
- ~FMDummy();
-
- virtual void readMap();
- virtual void freeMap();
-
- double zbegin_m;
- double zend_m;
-
- friend class Fieldmap;
-};
-
-#endif
diff --git a/src/Classic/Fields/Fieldmap.cpp b/src/Classic/Fields/Fieldmap.cpp
index 9fb9062ba847560f2e6687e50f8f65c978726bc5..552d9e4f9d1799bfec23a4ac4261145b4aa0dbba 100644
--- a/src/Classic/Fields/Fieldmap.cpp
+++ b/src/Classic/Fields/Fieldmap.cpp
@@ -2,36 +2,35 @@
#include "Utility/PAssert.h"
-#include "Fields/FM3DDynamic.h"
-#include "Fields/FM3DH5BlockBase.h"
-#include "Fields/FM3DH5Block.h"
-#include "Fields/FM3DH5Block_nonscale.h"
-#include "Fields/FM3DMagnetoStaticH5Block.h"
-#include "Fields/FM3DMagnetoStatic.h"
-#include "Fields/FM3DMagnetoStaticExtended.h"
-#include "Fields/FM2DDynamic.h"
-#include "Fields/FM2DElectroStatic.h"
-#include "Fields/FM2DMagnetoStatic.h"
-#include "Fields/FM1DDynamic.h"
-#include "Fields/FM1DDynamic_fast.h"
+#include "AbstractObjects/OpalData.h"
#include "Fields/Astra1DDynamic.h"
#include "Fields/Astra1DDynamic_fast.h"
-#include "Fields/FM1DElectroStatic.h"
-#include "Fields/FM1DElectroStatic_fast.h"
#include "Fields/Astra1DElectroStatic.h"
#include "Fields/Astra1DElectroStatic_fast.h"
-#include "Fields/FM1DMagnetoStatic.h"
-#include "Fields/FM1DMagnetoStatic_fast.h"
#include "Fields/Astra1DMagnetoStatic.h"
#include "Fields/Astra1DMagnetoStatic_fast.h"
+#include "Fields/FM1DDynamic.h"
+#include "Fields/FM1DDynamic_fast.h"
+#include "Fields/FM1DElectroStatic.h"
+#include "Fields/FM1DElectroStatic_fast.h"
+#include "Fields/FM1DMagnetoStatic.h"
+#include "Fields/FM1DMagnetoStatic_fast.h"
#include "Fields/FM1DProfile1.h"
#include "Fields/FM1DProfile2.h"
-#include "Fields/FMDummy.h"
+#include "Fields/FM2DDynamic.h"
+#include "Fields/FM2DElectroStatic.h"
+#include "Fields/FM2DMagnetoStatic.h"
+#include "Fields/FM3DDynamic.h"
+#include "Fields/FM3DH5Block.h"
+#include "Fields/FM3DH5BlockBase.h"
+#include "Fields/FM3DH5Block_nonscale.h"
+#include "Fields/FM3DMagnetoStatic.h"
+#include "Fields/FM3DMagnetoStaticExtended.h"
+#include "Fields/FM3DMagnetoStaticH5Block.h"
+#include "Physics/Physics.h"
#include "Utilities/GeneralClassicException.h"
#include "Utilities/Options.h"
#include "Utilities/Util.h"
-#include "AbstractObjects/OpalData.h"
-#include "Physics/Physics.h"
#include "H5hut.h"
@@ -44,10 +43,10 @@
namespace fs = boost::filesystem;
-#define REGISTER_PARSE_TYPE(X) template <> struct Fieldmap::TypeParseTraits<X> \
- { static const char* name; } ; const char* Fieldmap::TypeParseTraits<X>::name = #X
+#define REGISTER_PARSE_TYPE(X) template <> struct _Fieldmap::TypeParseTraits<X> \
+ { static const char* name; } ; const char* _Fieldmap::TypeParseTraits<X>::name = #X
-Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
+Fieldmap _Fieldmap::getFieldmap(std::string Filename, bool fast) {
std::map<std::string, FieldmapDescription>::iterator position = FieldmapDictionary.find(Filename);
if (position != FieldmapDictionary.end()) {
(*position).second.RefCounter++;
@@ -62,14 +61,14 @@ Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- T1DDynamic, new FM1DDynamic_fast(Filename))));
+ FieldmapDescription(T1DDynamic,
+ _FM1DDynamic_fast::create(Filename))));
} else {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- T1DDynamic, new FM1DDynamic(Filename))));
+ FieldmapDescription(T1DDynamic,
+ _FM1DDynamic::create(Filename))));
}
return (*position.first).second.Map;
break;
@@ -79,14 +78,14 @@ Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- TAstraDynamic, new Astra1DDynamic_fast(Filename))));
+ FieldmapDescription(TAstraDynamic,
+ _Astra1DDynamic_fast::create(Filename))));
} else {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- TAstraDynamic, new Astra1DDynamic(Filename))));
+ FieldmapDescription(TAstraDynamic,
+ _Astra1DDynamic::create(Filename))));
}
return (*position.first).second.Map;
break;
@@ -96,14 +95,14 @@ Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- T1DElectroStatic, new FM1DElectroStatic_fast(Filename))));
+ FieldmapDescription(T1DElectroStatic,
+ _FM1DElectroStatic_fast::create(Filename))));
} else {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- T1DElectroStatic, new FM1DElectroStatic(Filename))));
+ FieldmapDescription(T1DElectroStatic,
+ _FM1DElectroStatic::create(Filename))));
}
return (*position.first).second.Map;
break;
@@ -113,14 +112,14 @@ Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- TAstraElectroStatic, new Astra1DElectroStatic_fast(Filename))));
+ FieldmapDescription(TAstraElectroStatic,
+ _Astra1DElectroStatic_fast::create(Filename))));
} else {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- TAstraElectroStatic, new Astra1DElectroStatic(Filename))));
+ FieldmapDescription(TAstraElectroStatic,
+ _Astra1DElectroStatic::create(Filename))));
}
return (*position.first).second.Map;
break;
@@ -130,14 +129,14 @@ Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- T1DMagnetoStatic, new FM1DMagnetoStatic_fast(Filename))));
+ FieldmapDescription(T1DMagnetoStatic,
+ _FM1DMagnetoStatic_fast::create(Filename))));
} else {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- T1DMagnetoStatic, new FM1DMagnetoStatic(Filename))));
+ FieldmapDescription(T1DMagnetoStatic,
+ _FM1DMagnetoStatic::create(Filename))));
}
return (*position.first).second.Map;
break;
@@ -147,14 +146,14 @@ Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- TAstraMagnetoStatic, new Astra1DMagnetoStatic_fast(Filename))));
+ FieldmapDescription(TAstraMagnetoStatic,
+ _Astra1DMagnetoStatic_fast::create(Filename))));
} else {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- TAstraMagnetoStatic, new Astra1DMagnetoStatic(Filename))));
+ FieldmapDescription(TAstraMagnetoStatic,
+ _Astra1DMagnetoStatic::create(Filename))));
}
return (*position.first).second.Map;
break;
@@ -163,7 +162,8 @@ Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(T1DProfile1, new FM1DProfile1(Filename))));
+ FieldmapDescription(T1DProfile1,
+ _FM1DProfile1::create(Filename))));
return (*position.first).second.Map;
break;
@@ -171,8 +171,8 @@ Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- T1DProfile2, new FM1DProfile2(Filename))));
+ FieldmapDescription(T1DProfile2,
+ _FM1DProfile2::create(Filename))));
return (*position.first).second.Map;
break;
@@ -180,8 +180,8 @@ Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- T2DDynamic, new FM2DDynamic(Filename))));
+ FieldmapDescription(T2DDynamic,
+ _FM2DDynamic::create(Filename))));
return (*position.first).second.Map;
break;
@@ -189,8 +189,8 @@ Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- T2DElectroStatic, new FM2DElectroStatic(Filename))));
+ FieldmapDescription(T2DElectroStatic,
+ _FM2DElectroStatic::create(Filename))));
return (*position.first).second.Map;
break;
@@ -198,8 +198,8 @@ Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- T2DMagnetoStatic, new FM2DMagnetoStatic(Filename))));
+ FieldmapDescription(T2DMagnetoStatic,
+ _FM2DMagnetoStatic::create(Filename))));
return (*position.first).second.Map;
break;
@@ -207,32 +207,32 @@ Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- T3DDynamic, new FM3DDynamic(Filename))));
+ FieldmapDescription(T3DDynamic,
+ _FM3DDynamic::create(Filename))));
return (*position.first).second.Map;
break;
case T3DMagnetoStaticH5Block:
position = FieldmapDictionary.insert(
std::make_pair(
- Filename, FieldmapDescription(
- T3DMagnetoStaticH5Block, new FM3DMagnetoStaticH5Block(Filename))));
+ Filename, FieldmapDescription(T3DMagnetoStaticH5Block,
+ _FM3DMagnetoStaticH5Block::create(Filename))));
return (*position.first).second.Map;
break;
case T3DMagnetoStatic:
position = FieldmapDictionary.insert(
std::make_pair(
- Filename, FieldmapDescription(
- T3DMagnetoStatic, new FM3DMagnetoStatic(Filename))));
+ Filename, FieldmapDescription(T3DMagnetoStatic,
+ _FM3DMagnetoStatic::create(Filename))));
return (*position.first).second.Map;
break;
case T3DMagnetoStatic_Extended:
position = FieldmapDictionary.insert(
std::make_pair(
- Filename, FieldmapDescription(
- T3DMagnetoStatic_Extended, new FM3DMagnetoStaticExtended(Filename))));
+ Filename, FieldmapDescription(T3DMagnetoStatic_Extended,
+ _FM3DMagnetoStaticExtended::create(Filename))));
return (*position.first).second.Map;
break;
@@ -241,26 +241,26 @@ Fieldmap *Fieldmap::getFieldmap(std::string Filename, bool fast) {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- T3DDynamic, new FM3DH5Block_nonscale(Filename))));
+ FieldmapDescription(T3DDynamic,
+ _FM3DH5Block_nonscale::create(Filename))));
} else {
position = FieldmapDictionary.insert(
std::make_pair(
Filename,
- FieldmapDescription(
- T3DDynamic, new FM3DH5Block(Filename))));
+ FieldmapDescription(T3DDynamic,
+ _FM3DH5Block::create(Filename))));
}
return (*position.first).second.Map;
break;
default:
- throw GeneralClassicException("Fieldmap::getFieldmap()",
+ throw GeneralClassicException("_Fieldmap::getFieldmap()",
"Couldn't determine type of fieldmap in file \"" + Filename + "\"");
}
}
}
-std::vector<std::string> Fieldmap::getListFieldmapNames() {
+std::vector<std::string> _Fieldmap::getListFieldmapNames() {
std::vector<std::string> name_list;
for (std::map<std::string, FieldmapDescription>::const_iterator it = FieldmapDictionary.begin(); it != FieldmapDictionary.end(); ++ it) {
name_list.push_back((*it).first);
@@ -268,20 +268,19 @@ std::vector<std::string> Fieldmap::getListFieldmapNames() {
return name_list;
}
-void Fieldmap::deleteFieldmap(std::string Filename) {
+void _Fieldmap::deleteFieldmap(std::string Filename) {
freeMap(Filename);
}
-void Fieldmap::clearDictionary() {
+void _Fieldmap::clearDictionary() {
std::map<std::string, FieldmapDescription>::iterator it = FieldmapDictionary.begin();
for (;it != FieldmapDictionary.end(); ++ it) {
- delete it->second.Map;
- it->second.Map = nullptr;
+ it->second.Map.reset();
}
FieldmapDictionary.clear();
}
-MapType Fieldmap::readHeader(std::string Filename) {
+MapType _Fieldmap::readHeader(std::string Filename) {
char magicnumber[5] = " ";
std::string buffer;
int lines_read_m = 0;
@@ -291,11 +290,11 @@ MapType Fieldmap::readHeader(std::string Filename) {
return T1DProfile1;
if (Filename.empty())
- throw GeneralClassicException("Fieldmap::readHeader()",
+ throw GeneralClassicException("_Fieldmap::readHeader()",
"No field map file specified");
if (!fs::exists(Filename))
- throw GeneralClassicException("Fieldmap::readHeader()",
+ throw GeneralClassicException("_Fieldmap::readHeader()",
"File '" + Filename + "' doesn't exist");
std::ifstream File(Filename.c_str());
@@ -421,7 +420,7 @@ MapType Fieldmap::readHeader(std::string Filename) {
return UNKNOWN;
}
-void Fieldmap::readMap(std::string Filename) {
+void _Fieldmap::readMap(std::string Filename) {
std::map<std::string, FieldmapDescription>::iterator position = FieldmapDictionary.find(Filename);
if (position != FieldmapDictionary.end())
if (!(*position).second.read) {
@@ -430,7 +429,7 @@ void Fieldmap::readMap(std::string Filename) {
}
}
-void Fieldmap::freeMap(std::string Filename) {
+void _Fieldmap::freeMap(std::string Filename) {
std::map<std::string, FieldmapDescription>::iterator position = FieldmapDictionary.find(Filename);
/*
FIXME: find( ) make problem, crashes
@@ -441,14 +440,13 @@ void Fieldmap::freeMap(std::string Filename) {
}
if ((*position).second.RefCounter == 0) {
- delete (*position).second.Map;
- (*position).second.Map = nullptr;
+ (*position).second.Map.reset();
FieldmapDictionary.erase(position);
}
}
}
-void Fieldmap::checkMap(unsigned int accuracy,
+void _Fieldmap::checkMap(unsigned int accuracy,
std::pair<double, double> fieldDimensions,
double deltaZ,
const std::vector<double> &fourierCoefficients,
@@ -464,7 +462,7 @@ void Fieldmap::checkMap(unsigned int accuracy,
checkMap(accuracy, length, zSampling, fourierCoefficients, splineCoefficients, splineAccelerator);
}
-void Fieldmap::checkMap(unsigned int accuracy,
+void _Fieldmap::checkMap(unsigned int accuracy,
double length,
const std::vector<double> &zSampling,
const std::vector<double> &fourierCoefficients,
@@ -519,7 +517,7 @@ void Fieldmap::checkMap(unsigned int accuracy,
if (std::sqrt(error / ezSquare) > 1e-1 || maxDiff > 1e-1 * ezMax) {
lowResolutionWarning(std::sqrt(error / ezSquare), maxDiff / ezMax);
- throw GeneralClassicException("Fieldmap::checkMap",
+ throw GeneralClassicException("_Fieldmap::checkMap",
"Field map can't be reproduced properly with the given number of fourier components");
}
if (std::sqrt(error / ezSquare) > 1e-2 || maxDiff > 1e-2 * ezMax) {
@@ -527,13 +525,13 @@ void Fieldmap::checkMap(unsigned int accuracy,
}
}
-void Fieldmap::setEdgeConstants(const double &/*bendAngle*/, const double &/*entranceAngle*/, const double &/*exitAngle*/)
+void _Fieldmap::setEdgeConstants(const double &/*bendAngle*/, const double &/*entranceAngle*/, const double &/*exitAngle*/)
{};
-void Fieldmap::setFieldLength(const double &)
+void _Fieldmap::setFieldLength(const double &)
{};
-void Fieldmap::getLine(std::ifstream &in, int &lines_read, std::string &buffer) {
+void _Fieldmap::getLine(std::ifstream &in, int &lines_read, std::string &buffer) {
size_t firstof = 0;
size_t lastof;
@@ -555,7 +553,7 @@ void Fieldmap::getLine(std::ifstream &in, int &lines_read, std::string &buffer)
}
}
-bool Fieldmap::interpreteEOF(std::ifstream &in) {
+bool _Fieldmap::interpreteEOF(std::ifstream &in) {
while(!in.eof()) {
++lines_read_m;
in.getline(buffer_m, READ_BUFFER_LENGTH);
@@ -571,7 +569,7 @@ bool Fieldmap::interpreteEOF(std::ifstream &in) {
return true;
}
-void Fieldmap::interpretWarning(const std::ios_base::iostate &state,
+void _Fieldmap::interpretWarning(const std::ios_base::iostate &state,
const bool &read_all,
const std::string &expecting,
const std::string &found) {
@@ -586,47 +584,47 @@ void Fieldmap::interpretWarning(const std::ios_base::iostate &state,
<< "expecting: '" << expecting << "' on line " << lines_read_m << ",\n"
<< "instead found: '" << found << "'." << std::endl;
}
- throw GeneralClassicException("Fieldmap::interpretWarning()",
+ throw GeneralClassicException("_Fieldmap::interpretWarning()",
errormsg.str());
}
-void Fieldmap::missingValuesWarning() {
+void _Fieldmap::missingValuesWarning() {
std::stringstream errormsg;
errormsg << "THERE SEEMS TO BE SOMETHING WRONG WITH YOUR FIELD MAP '" << Filename_m << "'.\n"
<< "There are only " << lines_read_m - 1 << " lines in the file, expecting more.\n"
<< "Please check the section about field maps in the user manual.";
- throw GeneralClassicException("Fieldmap::missingValuesWarning()",
+ throw GeneralClassicException("_Fieldmap::missingValuesWarning()",
errormsg.str());
}
-void Fieldmap::exceedingValuesWarning() {
+void _Fieldmap::exceedingValuesWarning() {
std::stringstream errormsg;
errormsg << "THERE SEEMS TO BE SOMETHING WRONG WITH YOUR FIELD MAP '" << Filename_m << "'.\n"
<< "There are too many lines in the file, expecting only " << lines_read_m << " lines.\n"
<< "Please check the section about field maps in the user manual.";
- throw GeneralClassicException("Fieldmap::exceedingValuesWarning()",
+ throw GeneralClassicException("_Fieldmap::exceedingValuesWarning()",
errormsg.str());
}
-void Fieldmap::disableFieldmapWarning() {
+void _Fieldmap::disableFieldmapWarning() {
std::stringstream errormsg;
errormsg << "DISABLING FIELD MAP '" + Filename_m + "' DUE TO PARSING ERRORS." ;
- throw GeneralClassicException("Fieldmap::disableFieldmapsWarning()",
+ throw GeneralClassicException("_Fieldmap::disableFieldmapsWarning()",
errormsg.str());
}
-void Fieldmap::noFieldmapWarning() {
+void _Fieldmap::noFieldmapWarning() {
std::stringstream errormsg;
errormsg << "DISABLING FIELD MAP '" << Filename_m << "' SINCE FILE COULDN'T BE FOUND!";
- throw GeneralClassicException("Fieldmap::noFieldmapsWarning()",
+ throw GeneralClassicException("_Fieldmap::noFieldmapsWarning()",
errormsg.str());
}
-void Fieldmap::lowResolutionWarning(double squareError, double maxError) {
+void _Fieldmap::lowResolutionWarning(double squareError, double maxError) {
std::stringstream errormsg;
errormsg << "IT SEEMS THAT YOU USE TOO FEW FOURIER COMPONENTS TO SUFFICIENTLY WELL\n"
<< "RESOLVE THE FIELD MAP '" << Filename_m << "'.\n"
@@ -649,7 +647,7 @@ void Fieldmap::lowResolutionWarning(double squareError, double maxError) {
}
}
-std::string Fieldmap::typeset_msg(const std::string &msg, const std::string &title) {
+std::string _Fieldmap::typeset_msg(const std::string &msg, const std::string &title) {
static std::string frame("* ******************************************************************************\n");
static unsigned int frame_width = frame.length() - 5;
static std::string closure(" *\n");
@@ -706,35 +704,35 @@ std::string Fieldmap::typeset_msg(const std::string &msg, const std::string &tit
return return_string;
}
-void Fieldmap::getOnaxisEz(std::vector<std::pair<double, double> > &/*onaxis*/)
+void _Fieldmap::getOnaxisEz(std::vector<std::pair<double, double> > &/*onaxis*/)
{ }
-void Fieldmap::get1DProfile1EngeCoeffs(std::vector<double> &/*engeCoeffsEntry*/,
+void _Fieldmap::get1DProfile1EngeCoeffs(std::vector<double> &/*engeCoeffsEntry*/,
std::vector<double> &/*engeCoeffsExit*/) {
}
-void Fieldmap::get1DProfile1EntranceParam(double &/*entranceParameter1*/,
+void _Fieldmap::get1DProfile1EntranceParam(double &/*entranceParameter1*/,
double &/*entranceParameter2*/,
double &/*entranceParameter3*/) {
}
-void Fieldmap::get1DProfile1ExitParam(double &/*exitParameter1*/,
+void _Fieldmap::get1DProfile1ExitParam(double &/*exitParameter1*/,
double &/*exitParameter2*/,
double &/*exitParameter3*/) {
}
-double Fieldmap::getFieldGap() {
+double _Fieldmap::getFieldGap() {
return 0.0;
}
-void Fieldmap::setFieldGap(double /*gap*/) {
+void _Fieldmap::setFieldGap(double /*gap*/) {
}
-void Fieldmap::write3DField(unsigned int nx,
+void _Fieldmap::write3DField(unsigned int nx,
unsigned int ny,
unsigned int nz,
const std::pair<double, double> &xrange,
@@ -813,6 +811,6 @@ REGISTER_PARSE_TYPE(unsigned int);
REGISTER_PARSE_TYPE(double);
REGISTER_PARSE_TYPE(std::string);
-std::string Fieldmap::alpha_numeric("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+\211");
-std::map<std::string, Fieldmap::FieldmapDescription> Fieldmap::FieldmapDictionary = std::map<std::string, Fieldmap::FieldmapDescription>();
-char Fieldmap::buffer_m[READ_BUFFER_LENGTH];
+std::string _Fieldmap::alpha_numeric("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-+\211");
+std::map<std::string, _Fieldmap::FieldmapDescription> _Fieldmap::FieldmapDictionary = std::map<std::string, _Fieldmap::FieldmapDescription>();
+char _Fieldmap::buffer_m[READ_BUFFER_LENGTH];
\ No newline at end of file
diff --git a/src/Classic/Fields/Fieldmap.h b/src/Classic/Fields/Fieldmap.h
index 9c01fa963b194280c8f7ae006f4450a52a22b28b..35888367bb588372560b4170c73230a698ec1eeb 100644
--- a/src/Classic/Fields/Fieldmap.h
+++ b/src/Classic/Fields/Fieldmap.h
@@ -7,6 +7,7 @@
#include <map>
#include <vector>
#include "Algorithms/Vektor.h"
+#include "Fields/Definitions.h"
#include "gsl/gsl_interp.h"
#include "gsl/gsl_spline.h"
@@ -57,11 +58,11 @@ enum DiffDirection {
DZ
};
-class Fieldmap {
+class _Fieldmap {
public:
- static Fieldmap *getFieldmap(std::string Filename, bool fast = false);
+ static Fieldmap getFieldmap(std::string Filename, bool fast = false);
static std::vector<std::string> getListFieldmapNames();
static void deleteFieldmap(std::string Filename);
static void clearDictionary();
@@ -104,14 +105,14 @@ public:
virtual void freeMap() = 0;
protected:
- Fieldmap () = delete;
+ _Fieldmap () = delete;
- Fieldmap(const std::string& aFilename)
- : Filename_m(aFilename),
+ _Fieldmap(const std::string& filename)
+ : Filename_m(filename),
lines_read_m(0),
normalize_m(true) { };
- virtual ~Fieldmap() { ;};
+ virtual ~_Fieldmap() { ;};
MapType Type;
std::string Filename_m;
@@ -183,10 +184,10 @@ private:
struct FieldmapDescription {
MapType Type;
- Fieldmap *Map;
+ Fieldmap Map;
unsigned int RefCounter;
bool read;
- FieldmapDescription(MapType aType, Fieldmap *aMap):
+ FieldmapDescription(MapType aType, Fieldmap aMap):
Type(aType),
Map(aMap),
RefCounter(1),
diff --git a/src/Classic/Fields/Fieldmap.hpp b/src/Classic/Fields/Fieldmap.hpp
index ded87c4a1f25110bac98c5ebdffa870d8bb26635..8343b75c07745774148f56ed3ab395ce8c398414 100644
--- a/src/Classic/Fields/Fieldmap.hpp
+++ b/src/Classic/Fields/Fieldmap.hpp
@@ -9,7 +9,7 @@
#include "Fields/Fieldmap.h"
template<class T>
-bool Fieldmap::interpretLine(std::ifstream & in, T & value, const bool & file_length_known)
+bool _Fieldmap::interpretLine(std::ifstream & in, T & value, const bool & file_length_known)
{
bool read_all = true;
std::string buffer;
@@ -36,7 +36,7 @@ bool Fieldmap::interpretLine(std::ifstream & in, T & value, const bool & file_le
}
template<class S, class T>
-bool Fieldmap::interpretLine(std::ifstream & in, S & value1, T & value2, const bool & file_length_known)
+bool _Fieldmap::interpretLine(std::ifstream & in, S & value1, T & value2, const bool & file_length_known)
{
bool read_all = true;
std::string buffer;
@@ -67,7 +67,7 @@ bool Fieldmap::interpretLine(std::ifstream & in, S & value1, T & value2, const b
}
template<class S, class T, class U>
-bool Fieldmap::interpretLine(std::ifstream & in, S & value1, T & value2, U & value3, const bool & file_length_known)
+bool _Fieldmap::interpretLine(std::ifstream & in, S & value1, T & value2, U & value3, const bool & file_length_known)
{
bool read_all = true;
std::string buffer;
@@ -101,7 +101,7 @@ bool Fieldmap::interpretLine(std::ifstream & in, S & value1, T & value2, U & val
}
template<class S, class T, class U, class V>
-bool Fieldmap::interpretLine(std::ifstream & in, S & value1, T & value2, U & value3, V & value4, const bool & file_length_known)
+bool _Fieldmap::interpretLine(std::ifstream & in, S & value1, T & value2, U & value3, V & value4, const bool & file_length_known)
{
bool read_all = true;
std::string buffer;
@@ -138,7 +138,7 @@ bool Fieldmap::interpretLine(std::ifstream & in, S & value1, T & value2, U & val
}
template<class S>
-bool Fieldmap::interpretLine(std::ifstream & in, S & value1, S & value2, S & value3, S & value4, S & value5, S & value6, const bool & file_length_known)
+bool _Fieldmap::interpretLine(std::ifstream & in, S & value1, S & value2, S & value3, S & value4, S & value5, S & value6, const bool & file_length_known)
{
bool read_all = true;
std::string buffer;
diff --git a/src/Classic/Utilities/MSLang/matheval.hpp b/src/Classic/Utilities/MSLang/matheval.hpp
index 33b3bd875f7b72bbeb32bc71ac01faa656875cc5..0644d15766eaf069b0c304520dee579be3a550a9 100644
--- a/src/Classic/Utilities/MSLang/matheval.hpp
+++ b/src/Classic/Utilities/MSLang/matheval.hpp
@@ -27,7 +27,7 @@
#define BOOST_RESULT_OF_USE_DECLTYPE
#define BOOST_SPIRIT_USE_PHOENIX_V3
#include <boost/math/constants/constants.hpp>
-#include <boost/spirit/include/phoenix.hpp>
+#include <boost/phoenix.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/variant.hpp>
diff --git a/src/Main.cpp b/src/Main.cpp
index e57e68f1839608076ed97290327a01dcf68139aa..a8b06fd5e34ce14b28156c0be67ba2aa669b254b 100644
--- a/src/Main.cpp
+++ b/src/Main.cpp
@@ -511,7 +511,7 @@ int opalMain(int argc, char *argv[]) {
OpalData::getInstance()->getProblemCharacteristicValues());
Ippl::Comm->barrier();
- Fieldmap::clearDictionary();
+ _Fieldmap::clearDictionary();
OpalData::deleteInstance();
delete gmsg;
diff --git a/src/ValueDefinitions/RealConstant.cpp b/src/ValueDefinitions/RealConstant.cpp
index 4111c76fc212feddd75df1758d0467a8617395ec..b8585d53dcdabe223117c70f93bfb0f3d4f7d4db 100644
--- a/src/ValueDefinitions/RealConstant.cpp
+++ b/src/ValueDefinitions/RealConstant.cpp
@@ -60,9 +60,8 @@ RealConstant::RealConstant():
opal->create(new RealConstant("CLIGHT", this, Physics::c));
opal->create(new RealConstant("AMU", this, Physics::amu));
- opal->create(new RealConstant("OPALVERSION", this, OPAL_VERSION_MAJOR * 10000
- + OPAL_VERSION_MINOR * 100
- + OPAL_VERSION_PATCH));
+ opal->create(new RealConstant("OPALVERSION", this, OPAL_VERSION_MAJOR*10
+ + OPAL_VERSION_MINOR));
opal->create(new RealConstant("RANK", this, Ippl::myNode()));
}
diff --git a/src/opal.cpp b/src/opal.cpp
index 7513dbe162ca68a0afe73aece2e4795a5f5eb3cf..3c2cbb18d090a5c95870221c28189b6a5ac37dc8 100644
--- a/src/opal.cpp
+++ b/src/opal.cpp
@@ -85,7 +85,7 @@ int run_opal(char */*args*/[], std::string inputfile, int restartStep,
// cleanup
//OPAL->reset();
OpalData::deleteInstance();
- Fieldmap::clearDictionary();
+ _Fieldmap::clearDictionary();
delete parser;
delete gmsg;
diff --git a/tests/opal_src/Elements/OpalAsymmetricEngeTest.cpp b/tests/opal_src/Elements/OpalAsymmetricEngeTest.cpp
index b81a809a60ad0fc8f0286b286699b188828d9311..413d43cc0446da974ef71d51386da92d54f60ca3 100644
--- a/tests/opal_src/Elements/OpalAsymmetricEngeTest.cpp
+++ b/tests/opal_src/Elements/OpalAsymmetricEngeTest.cpp
@@ -1,27 +1,27 @@
-/*
+/*
* Copyright (c) 2014, Chris Rogers
* All rights reserved.
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
- * 3. Neither the name of STFC nor the names of its contributors may be used to
- * endorse or promote products derived from this software without specific
+ * 3. Neither the name of STFC nor the names of its contributors may be used to
+ * endorse or promote products derived from this software without specific
* prior written permission.
*
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
@@ -40,7 +40,7 @@ void setReal(OpalAsymmetricEnge& enge, std::string attName, double value) {
}
void setRealArray(OpalAsymmetricEnge& enge,
- std::string attName,
+ std::string attName,
std::vector<double> value) {
Attribute* att = enge.findAttribute(attName);
ASSERT_NE(att, nullptr);
@@ -65,16 +65,13 @@ TEST(OpalAsymmetricEngeTest, TestUpdate) {
std::shared_ptr<Enge> engeEnd = myEnge->getEngeEnd();
EXPECT_EQ(myEnge->getX0Start(), 1.0);
EXPECT_EQ(engeStart->getLambda(), 2.0);
- ASSERT_EQ(engeStart->getCoefficients().size(), 2);
+ ASSERT_EQ(engeStart->getCoefficients().size(), 2u);
EXPECT_EQ(engeStart->getCoefficients()[0], 3.0);
EXPECT_EQ(engeStart->getCoefficients()[1], 4.0);
EXPECT_EQ(myEnge->getX0End(), -1.0);
EXPECT_EQ(engeEnd->getLambda(), -2.0);
- ASSERT_EQ(engeEnd->getCoefficients().size(), 3);
+ ASSERT_EQ(engeEnd->getCoefficients().size(), 3u);
EXPECT_EQ(engeEnd->getCoefficients()[0], -3.0);
EXPECT_EQ(engeEnd->getCoefficients()[1], -4.0);
EXPECT_EQ(engeEnd->getCoefficients()[2], -5.0);
-}
-
-
-
+}
\ No newline at end of file
diff --git a/tests/opal_src/Elements/OpalEngeTest.cpp b/tests/opal_src/Elements/OpalEngeTest.cpp
index 672c20f51863ceea0a4b24707d16718e7e25cb88..d3cf1944811ba684658956800fa41ec100f48f4b 100644
--- a/tests/opal_src/Elements/OpalEngeTest.cpp
+++ b/tests/opal_src/Elements/OpalEngeTest.cpp
@@ -1,27 +1,27 @@
-/*
+/*
* Copyright (c) 2014, Chris Rogers
* All rights reserved.
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
- * 3. Neither the name of STFC nor the names of its contributors may be used to
- * endorse or promote products derived from this software without specific
+ * 3. Neither the name of STFC nor the names of its contributors may be used to
+ * endorse or promote products derived from this software without specific
* prior written permission.
*
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
@@ -39,7 +39,7 @@ void setReal(OpalEnge& enge, std::string attName, double value) {
}
void setRealArray(OpalEnge& enge,
- std::string attName,
+ std::string attName,
std::vector<double> value) {
Attribute* att = enge.findAttribute(attName);
ASSERT_NE(att, nullptr);
@@ -60,10 +60,7 @@ TEST(OpalEngeTest, TestUpdate) {
Enge* myEnge = dynamic_cast<Enge*>(myEFM.get());
EXPECT_EQ(myEnge->getX0(), 1.0);
EXPECT_EQ(myEnge->getLambda(), 2.0);
- ASSERT_EQ(myEnge->getCoefficients().size(), 2);
+ ASSERT_EQ(myEnge->getCoefficients().size(), 2u);
EXPECT_EQ(myEnge->getCoefficients()[0], 3.0);
EXPECT_EQ(myEnge->getCoefficients()[1], 4.0);
-}
-
-
-
+}
\ No newline at end of file
diff --git a/tests/opal_src/Elements/OpalScalingFFAMagnetTest.cpp b/tests/opal_src/Elements/OpalScalingFFAMagnetTest.cpp
index 8bf1e25a597edf5f445589dfe912eb6f01f30de9..025b0010c0d9a6f316e4129e710b0c78a6b5e223 100644
--- a/tests/opal_src/Elements/OpalScalingFFAMagnetTest.cpp
+++ b/tests/opal_src/Elements/OpalScalingFFAMagnetTest.cpp
@@ -50,7 +50,7 @@ TEST(OpalScalingFFAMagnetTest, TestUpdate) {
EXPECT_NEAR(mag1->getR0(), 12.5*Units::m2mm, 1e-9);
EXPECT_NEAR(mag1->getFieldIndex(), 2.0, 1e-9);
EXPECT_NEAR(mag1->getTanDelta(), 0.7, 1e-9);
- EXPECT_EQ(mag1->getMaxOrder(), 3);
+ EXPECT_EQ(mag1->getMaxOrder(), 3u);
EXPECT_NEAR(mag1->getRMin(), 11.95*Units::m2mm, 1e-9);
EXPECT_NEAR(mag1->getRMax(), 13.15*Units::m2mm, 1e-9);
EXPECT_NEAR(mag1->getVerticalExtent(), 3.0*Units::m2mm, 1e-9);
@@ -115,10 +115,10 @@ TEST(OpalScalingFFAMagnetTest, TestFieldCheck) {
Vector_t B, P, E;
double t = 0.;
// magnet start plus half centre length should have maximum field
- Vector_t rMiddle = cartesianCoord(r0mm, phi);
+ Vector_t rMiddle = cartesianCoord(r0mm, phi);
bool outOfBounds = mag1->apply(rMiddle, P, t, E, B);
EXPECT_EQ(outOfBounds, oob[i]);
- EXPECT_NEAR(B[1], field[i], 1e-4) << "failed for phi "
+ EXPECT_NEAR(B[1], field[i], 1e-4) << "failed for phi "
<< position[i] << "*PI/64 " << std::endl;
}
@@ -133,5 +133,4 @@ TEST(OpalScalingFFAMagnetTest, TestFieldCheck) {
EXPECT_EQ(rot(1), -mag1->getPhiEnd());
EXPECT_EQ(rot(2), 0.);
-}
-
+}
\ No newline at end of file