59 Tracker(beamline, reference, revBeam, revTrack),
61 itsOpalBeamline_m(beamline.getOrigin3D(), beamline.getInitialDirection()),
67 dtCurrentTrack_m(0.0),
68 minStepforReBin_m(-1),
69 minBinEmitted_m(std::numeric_limits<size_t>::
max()),
71 emissionSteps_m(std::numeric_limits<unsigned int>::
max()),
72 numParticlesInSimulation_m(0),
73 timeIntegrationTimer1_m(
IpplTimings::getTimer(
"TIntegration1")),
74 timeIntegrationTimer2_m(
IpplTimings::getTimer(
"TIntegration2")),
75 fieldEvaluationTimer_m(
IpplTimings::getTimer(
"External field eval")),
76 BinRepartTimer_m(
IpplTimings::getTimer(
"Binaryrepart")),
77 WakeFieldTimer_m(
IpplTimings::getTimer(
"WakeField")),
78 particleMatterStatus_m(false),
79 totalParticlesInSimulation_m(0)
94 const std::vector<unsigned long long> &maxSteps,
96 const std::vector<double> &zstop,
97 const std::vector<double> &dt):
98 Tracker(beamline, bunch, reference, revBeam, revTrack),
100 itsOpalBeamline_m(beamline.getOrigin3D(), beamline.getInitialDirection()),
103 wakeFunction_m(NULL),
106 dtCurrentTrack_m(0.0),
107 minStepforReBin_m(-1),
108 minBinEmitted_m(std::numeric_limits<size_t>::
max()),
110 emissionSteps_m(std::numeric_limits<unsigned int>::
max()),
111 numParticlesInSimulation_m(0),
112 timeIntegrationTimer1_m(
IpplTimings::getTimer(
"TIntegration1")),
113 timeIntegrationTimer2_m(
IpplTimings::getTimer(
"TIntegration2")),
114 fieldEvaluationTimer_m(
IpplTimings::getTimer(
"External field eval")),
115 BinRepartTimer_m(
IpplTimings::getTimer(
"Binaryrepart")),
116 WakeFieldTimer_m(
IpplTimings::getTimer(
"WakeField")),
117 particleMatterStatus_m(false),
118 totalParticlesInSimulation_m(0)
120 for (
unsigned int i = 0; i < zstop.size(); ++ i) {
158 cavities.insert(cavities.end(), travelingwaves.begin(), travelingwaves.end());
161 if ((*fit).getElement()->getName() == elName) {
168 INFOMSG(
"Restored cavity phase from the h5 file. Name: " << element->
getName() <<
", phase: " << maxPhase <<
" rad" <<
endl);
185 for (; it < end; ++ it) {
301 allocateDeviceMemory();
313 for (; step < trackSteps; ++ step) {
378 msg <<
level2 <<
"Dump phase space of last step" <<
endl;
383 *
gmsg <<
"done executing ParallelTTracker at " << myt3.
time() <<
endl;
444 pushParticlesDKS(
false);
457 for (
unsigned int i = 0; i < localNum; ++ i) {
481 for (
unsigned int i = 0; i < localNum; ++ i) {
531 for (
unsigned int i = 0; i < localNum1; ++ i) {
561 for (
unsigned int i = 0; i < localNum2; ++ i) {
573 bool locPartOutOfBounds =
false, globPartOutOfBounds =
false;
580 elements = oth.
query(
pathLength_m + 0.5 * (rmax(2) + rmin(2)), rmax(2) - rmin(2));
586 IndexMap::value_t::const_iterator it = elements.begin();
587 const IndexMap::value_t::const_iterator end = elements.end();
589 for (; it != end; ++ it) {
596 for (
unsigned int i = 0; i < localNum; ++ i) {
605 if ((*it)->apply(i,
itsBunch_m->
getT() + 0.5 * dt, localE, localB)) {
609 locPartOutOfBounds =
true;
629 if (globPartOutOfBounds) {
646 msg <<
level1 <<
"* Deleted " << ne <<
" particles, "
652 bool hasWake =
false;
659 IndexMap::value_t::const_iterator it = elements.begin();
660 const IndexMap::value_t::const_iterator end = elements.end();
662 for (; it != end; ++ it) {
663 if ((*it)->hasWake() && !hasWake) {
668 if ((*it)->getWake()->getType() ==
"CSRWakeFunction" ||
669 (*it)->getWake()->getType() ==
"CSRIGFWakeFunction") {
672 wfInstance = (*it)->getWake();
678 wfInstance = (*it)->getWake();
683 "empty wake function");
687 msg <<
level2 <<
"============== START WAKE CALCULATION =============" <<
endl;
698 for (
unsigned int i = 0; i < localNum; ++ i) {
706 for (
unsigned int i = 0; i < localNum; ++ i) {
717 msg <<
level2 <<
"=============== END WAKE CALCULATION ==============" <<
endl;
724 std::set<IndexMap::value_t::value_type> elementsWithParticleMatterInteraction;
725 std::set<ParticleMatterInteractionHandler*> particleMatterinteractionHandlers;
726 std::pair<double, double> currentRange(0.0, 0.0);
728 while (elements.size() > 0) {
729 auto it = elements.begin();
730 if ((*it)->hasParticleMatterInteraction()) {
731 elementsWithParticleMatterInteraction.insert(*it);
732 particleMatterinteractionHandlers.insert((*it)->getParticleMatterInteraction());
735 currentRange.first =
std::min(currentRange.first, range.first);
736 currentRange.second =
std::max(currentRange.second, range.second);
739 elements.insert(touching.begin(), touching.end());
745 if (elementsWithParticleMatterInteraction.size() > 0) {
746 std::set<ParticleMatterInteractionHandler*> oldSPHandlers;
747 std::vector<ParticleMatterInteractionHandler*> leftBehindSPHandlers, newSPHandlers;
749 oldSPHandlers.insert(it);
752 leftBehindSPHandlers.resize(
std::max(oldSPHandlers.size(),
753 particleMatterinteractionHandlers.size()));
754 auto last = std::set_difference(oldSPHandlers.begin(), oldSPHandlers.end(),
755 particleMatterinteractionHandlers.begin(), particleMatterinteractionHandlers.end(),
756 leftBehindSPHandlers.begin());
757 leftBehindSPHandlers.resize(last - leftBehindSPHandlers.begin());
759 for (
auto it: leftBehindSPHandlers) {
760 if (!it->stillActive()) {
761 activeParticleMatterInteractionHandlers_m.erase(it);
765 newSPHandlers.resize(
std::max(oldSPHandlers.size(),
766 elementsWithParticleMatterInteraction.size()));
767 last = std::set_difference(particleMatterinteractionHandlers.begin(), particleMatterinteractionHandlers.end(),
768 oldSPHandlers.begin(), oldSPHandlers.end(),
769 newSPHandlers.begin());
770 newSPHandlers.resize(last - newSPHandlers.begin());
772 for (
auto it: newSPHandlers) {
773 activeParticleMatterInteractionHandlers_m.insert(it);
777 msg <<
level2 <<
"============== START PARTICLE MATTER INTERACTION CALCULATION =============" <<
endl;
787 int degradersWithParticlesCount = 0;
790 if (it->getParticlesInMat() > 0) {
791 onlyDegraderWithParticles = it;
792 ++ degradersWithParticlesCount;
799 unsigned int totalNum = 0;
801 bool allParticlesInMat = (totalNum == 0 &&
802 degradersWithParticlesCount == 1);
804 if (allParticlesInMat) {
806 msg <<
"All particles in degrader" <<
endl;
810 unsigned int rediffusedParticles = 0;
811 unsigned int numEnteredParticles = 0;
812 for (
auto it: activeParticleMatterInteractionHandlers_m) {
819 for (
unsigned int i = 0; i < localNum; ++i) {
823 boundingSphere.first = refToLocalCSTrafo.
transformTo(boundingSphere.first);
828 boundingSphere.first = localToRefCSTrafo.
transformTo(boundingSphere.first);
831 for (
unsigned int i = 0; i < newLocalNum; ++i) {
836 rediffusedParticles += it->getRediffused();
837 numEnteredParticles += it->getNumEntered();
840 if (it->getFlagAllParticlesIn()) {
842 if (timeDifference > 0.0) {
847 for (
unsigned int i = 0; i < numSteps; ++ i) {
858 if (numEnteredParticles > 0 || rediffusedParticles > 0) {
859 totalNum -= (numEnteredParticles + rediffusedParticles);
875 msg <<
level2 <<
"============== END PARTICLE MATTER INTERACTION CALCULATION =============" <<
endl;
885 INFOMSG(
"*****************************************************************" <<
endl);
886 INFOMSG(
"do repartition because of repartFreq_m" <<
endl);
887 INFOMSG(
"*****************************************************************" <<
endl);
892 INFOMSG(
"*****************************************************************" <<
endl);
894 INFOMSG(
"*****************************************************************" <<
endl);
911 msg << myt2.
time() <<
" "
913 <<
" -- no emission yet -- "
922 msg << myt2.
time() <<
" "
924 <<
"only " << std::setw(4) << totalParticles_f <<
" particles emitted; "
930 "there seems to be something wrong with the position of the bunch!");
933 msg << myt2.
time() <<
" "
980 for (
unsigned int i = 0; i < localNum; ++i) {
1000 Inform msg(
"OPAL ", *gmsg);
1010 if (psDump || statDump) {
1023 std::vector<std::pair<std::string, unsigned int> > collimatorLosses;
1025 if (collimators.size() != 0) {
1029 unsigned int losses = coll->
getLosses();
1030 collimatorLosses.push_back(std::make_pair(name, losses));
1032 std::sort(collimatorLosses.begin(), collimatorLosses.end(),
1033 [](
const std::pair<std::string, unsigned int>& a,
const std::pair<std::string, unsigned int>& b) ->
bool {
1034 return a.first < b.first;
1036 std::vector<unsigned int> bareLosses(collimatorLosses.size(),0);
1037 for (
size_t i = 0; i < collimatorLosses.size(); ++ i){
1038 bareLosses[i] = collimatorLosses[i].second;
1041 reduce(&bareLosses[0], &bareLosses[0] + bareLosses.size(), &bareLosses[0],
OpAddAssign());
1043 for (
size_t i = 0; i < collimatorLosses.size(); ++ i){
1044 collimatorLosses[i].second = bareLosses[i];
1050 msg <<
level3 <<
"* Wrote beam statistics." <<
endl;
1063 if (driftToCorrectPosition) {
1066 stashedR.
create(localNum);
1070 for (
size_t i = 0; i < localNum; ++ i) {
1091 if (driftToCorrectPosition) {
1094 stashedR.
destroy(localNum, 0);
1103 msg <<
level2 <<
"* Wrote beam phase space." <<
endl;
1124 IndexMap::value_t::const_iterator it = elements.begin();
1125 const IndexMap::value_t::const_iterator end = elements.end();
1127 for (; it != end; ++ it) {
1134 if ((*it)->applyToReferenceParticle(localR,
1139 *
gmsg <<
level1 <<
"The reference particle hit an element" <<
endl;
1156 for (
unsigned int i = 0; i < localNum; ++i) {
1262 for (
auto element: elementSet) {
1298 std::vector<long> localParticles(numNodes, 0);
1304 std::vector<DistributionInfo> send;
1305 std::vector<DistributionInfo> receive;
1308 if (localParticles[i] <= 0)
continue;
1311 if (j == i || localParticles[j] >= 0)
continue;
1313 long numParts =
std::min(localParticles[i], -localParticles[j]);
1314 localParticles[i] -= numParts;
1315 localParticles[j] += numParts;
1324 send.push_back(request);
1326 receive.push_back(request);
1330 if (localParticles[i] == 0)
break;
1334 std::vector<MPI_Request> requests;
1335 const long sizeSingleParticle = 9 *
sizeof(double) +
sizeof(
short) +
sizeof(int) +
sizeof(
PID_t::Return_t);
1339 std::vector<char> send_msgbuf;
1341 if (send.size() > 0) {
1344 unsigned int totalSend = 0, startIndex = 0;
1346 totalSend += request.howMany;
1348 send_msgbuf.reserve(totalSend * sizeSingleParticle);
1351 size_t sizePrior = send_msgbuf.size();
1352 for (
long i = 0; i < request.howMany; ++ i, -- idx) {
1353 buffer =
reinterpret_cast<const char*
>(&(
itsBunch_m->
R[idx](0)));
1354 send_msgbuf.insert(send_msgbuf.end(), buffer, buffer + 3 *
sizeof(double));
1355 buffer =
reinterpret_cast<const char*
>(&(
itsBunch_m->
P[idx](0)));
1356 send_msgbuf.insert(send_msgbuf.end(), buffer, buffer + 3 *
sizeof(double));
1357 buffer =
reinterpret_cast<const char*
>(&(
itsBunch_m->
Q[idx]));
1358 send_msgbuf.insert(send_msgbuf.end(), buffer, buffer +
sizeof(double));
1359 buffer =
reinterpret_cast<const char*
>(&(
itsBunch_m->
M[idx]));
1360 send_msgbuf.insert(send_msgbuf.end(), buffer, buffer +
sizeof(double));
1361 buffer =
reinterpret_cast<const char*
>(&(
itsBunch_m->
dt[idx]));
1362 send_msgbuf.insert(send_msgbuf.end(), buffer, buffer +
sizeof(double));
1364 send_msgbuf.insert(send_msgbuf.end(), buffer, buffer +
sizeof(short));
1366 send_msgbuf.insert(send_msgbuf.end(), buffer, buffer +
sizeof(int));
1367 buffer =
reinterpret_cast<const char*
>(&(
itsBunch_m->
ID[idx]));
1368 send_msgbuf.insert(send_msgbuf.end(), buffer, buffer +
sizeof(
PID_t::Return_t));
1371 size_t sendSizeThis = send_msgbuf.size() - sizePrior;
1377 requests.push_back(req);
1379 startIndex += sendSizeThis;
1385 for (
unsigned int i = 0; i < receive.size(); ++ i) {
1392 while (j < bufsize) {
1396 const double *buffer =
reinterpret_cast<const double*
>(recvbuf + j);
1403 j += 9 *
sizeof(double);
1406 const short *buffer =
reinterpret_cast<const short*
>(recvbuf + j);
1412 const int *buffer =
reinterpret_cast<const int*
>(recvbuf + j);
1427 if (requests.size() > 0) {
1428 MPI_Waitall(requests.size(), &(requests[0]), MPI_STATUSES_IGNORE);
ParticleAttrib< Vector_t > P
void switchOffUnitlessPositions(bool use_dt_per_particle=false)
double getMinTimeStep() const
void getMisalignment(double &x, double &y, double &s) const
void pushParticles(const BorisPusher &pusher)
WakeFunction * wakeFunction_m
std::vector< MaxPhasesT >::iterator getLastMaxPhases()
PETE_TUTree< FnAbs, typename T::PETE_Expr_t > abs(const PETE_Expr< T > &l)
void setPriorTrack(const bool &value=true)
true if in follow-up track
void findStartPosition(const BorisPusher &pusher)
int getLastEmittedEnergyBin()
constexpr double e
The value of .
void destroy(size_t M, size_t I, bool doNow=false)
ParticleAttrib< Vector_t > Ef
Interface for basic beam line object.
void setOpenMode(OPENMODE openMode)
virtual void create(size_t)
bool getRelativeFlag() const
void transformBunch(const CoordinateSystemTrafo &trafo)
Vector_t rotateTo(const Vector_t &r) const
const Beamline & itsBeamline_m
unsigned long totalParticlesInSimulation_m
virtual void execute()
Apply the algorithm to the top-level beamline.
virtual void visitBeamline(const Beamline &)
Apply the algorithm to a beam line.
void doBinaryRepartition()
void setGlobalMeanR(Vector_t globalMeanR)
T::PETE_Expr_t::PETE_Return_t max(const PETE_Expr< T > &expr, NDIndex< D > &loc)
The base class for all OPAL exceptions.
virtual double getReal() const
Return value.
PETE_TBTree< FnCopysign, PETE_Scalar< Vektor< T1, Dim > >, typename T2::PETE_Expr_t > copysign(const Vektor< T1, Dim > &l, const PETE_Expr< T2 > &r)
ParticleAttrib< double > Q
std::list< ClassicField > FieldList
PETE_TUTree< FnCeil, typename T::PETE_Expr_t > ceil(const PETE_Expr< T > &l)
IpplTimings::TimerRef timeIntegrationTimer1_m
virtual MPI_Request raw_isend(void *, int, int, int)
virtual int raw_probe_receive(char *&, int &, int &)
void updateReferenceParticle(const BorisPusher &pusher)
int getNumberOfEnergyBins()
The REAL VARIABLE definition.
virtual void do_binaryRepart()
void sortAscendingZStop()
double getPhaseAtMaxEnergy(const Vector_t &R, const Vector_t &P, double t, double dt)
IpplTimings::TimerRef fieldEvaluationTimer_m
unsigned int emissionSteps_m
int minStepForRebin
The number of steps into the simulation before the bins are squashed into a single bin...
double get_meanKineticEnergy() const
virtual const std::string & getName() const
Get element name.
Vector_t transformTo(const Vector_t &r) const
unsigned int repartFreq_m
Quaternion getQuaternion(Vector_t u, Vector_t ref)
virtual bool getAutophaseVeto() const
Vector_t get_pmean_Distribution() const
PETE_TBTree< OpNE, Index::PETE_Expr_t, PETE_Scalar< double > > ne(const Index &idx, double x)
unsigned long long getNumStepsFinestResolution() const
size_t numParticlesInSimulation_m
IpplTimings::TimerRef BinRepartTimer_m
unsigned long getFieldAt(const unsigned int &, const Vector_t &, const long &, const double &, Vector_t &, Vector_t &)
void updateReference(const BorisPusher &pusher)
std::string getLengthString(double spos, unsigned int precision=3)
unsigned long long getMaxSteps() const
Vector_t getOrigin3D() const
void kickParticles(const BorisPusher &pusher)
void updateRefToLabCSTrafo()
size_t getTotalNum() const
void computeParticleMatterInteraction(IndexMap::value_t elements, OrbitThreader &oth)
double getFinalZStop() const
virtual void resetInterpolationCache(bool clearCache=false)
void restoreCavityPhases()
int next_tag(int t, int s=1000)
IndexMap::value_t getTouchingElements(const std::pair< double, double > &range)
int statDumpFreq
The frequency to dump statistical values, e.e. dump data when stepstatDumpFreq==0.
double zstart_m
where to start
Vector_t transformToLocalCS(const std::shared_ptr< Component > &comp, const Vector_t &r) const
Inform & level2(Inform &inf)
void updateRFElement(std::string elName, double maxPhi)
OpalBeamline itsOpalBeamline_m
virtual void apply(PartBunchBase< double, 3 > *bunch)=0
void computeWakefield(IndexMap::value_t &elements)
bool reduce(Communicate &, InputIterator, InputIterator, OutputIterator, const ReduceOp &, bool *IncludeVal=0)
static OpalData * getInstance()
void computeExternalFields(OrbitThreader &oth)
void writePhaseSpace(const long long step, bool psDump, bool statDump)
bool hasEndOfLineReached()
void calcBeamParameters()
Vector_t get_pmean() const
Template class for beam lines.
double getGamma(Vector_t p)
ParticleAttrib< short > PType
double getGlobalPhaseShift()
units: (sec)
void applyFractionalStep(const BorisPusher &pusher, double tau)
void computeSpaceChargeFields(unsigned long long step)
virtual void accept(BeamlineVisitor &visitor) const =0
Apply visitor.
bool particleMatterStatus_m
IpplTimings::TimerRef WakeFieldTimer_m
void shiftZStopLeft(double back)
int repartFreq
The frequency to do particles repartition for better load balance between nodes.
std::string getTimeString(double time, unsigned int precision=3)
void changeDT(bool backTrack=false)
ParticleAttrib< int > TriID
IpplTimings::TimerRef timeIntegrationTimer2_m
void allreduce(const T *input, T *output, int count, Op op)
constexpr double c
The velocity of light in m/s.
static void startTimer(TimerRef t)
void switchElementsOff(const double &, ElementBase::ElementType eltype=ElementBase::ANY)
void kick(const Vector_t &R, Vector_t &P, const Vector_t &Ef, const Vector_t &Bf, const double &dt) const
CoordinateSystemTrafo toLabTrafo_m
StepSizeConfig stepSizes_m
virtual void iterate(BeamlineVisitor &, bool r2l) const
Apply visitor to all elements of the line.
IndexMap::value_t query(IndexMap::key_t::first_type step, IndexMap::key_t::second_type length)
void dumpH5(PartBunchBase< double, 3 > *beam, Vector_t FDext[]) const
FieldList getElementByType(ElementBase::ElementType)
void switchToUnitlessPositions(bool use_dt_per_particle=false)
Tps< T > pow(const Tps< T > &x, int y)
Integer power.
virtual void computeSelfFields()=0
Vektor< double, 3 > Vector_t
void swap(OpalBeamline &rhs)
void emitParticles(long long step)
An abstract sequence of beam line components.
const PartData itsReference
The reference information.
size_t getLocalNum() const
Vector_t get_centroid() const
virtual void destroy(size_t M, size_t I, bool optDestroy=true)
void timeIntegration2(BorisPusher &pusher)
Tps< T > sqrt(const Tps< T > &x)
Square root.
std::vector< MaxPhasesT >::iterator getFirstMaxPhases()
int psDumpFreq
The frequency to dump the phase space, i.e.dump data when steppsDumpFreq==0.
ParticleAttrib< double > dt
double getP() const
The constant reference momentum per particle.
void push_back(double dt, double zstop, unsigned long numSteps)
virtual void setAutophaseVeto(bool veto=true)
virtual void setPhasem(double phase)
std::pair< Vector_t, double > getLocalBoundingSphere()
static void writeStatistics()
std::string time() const
Return time.
Vector_t rotateToLocalCS(const std::shared_ptr< Component > &comp, const Vector_t &r) const
std::set< std::shared_ptr< Component > > getElements(const Vector_t &x)
Object * find(const std::string &name)
Find entry.
void setGlobalPhaseShift(double shift)
units: (sec)
int minBinEmitted
The number of bins that have to be emitted before the bin are squashed into a single bin...
std::pair< double, double > getRange(const IndexMap::value_t::value_type &element, double position) const
unsigned long getNumSteps() const
CoordinateSystemTrafo getCSTrafoLab2Local(const std::shared_ptr< Component > &comp) const
T euclidean_norm(const Vector< T > &)
Euclidean norm.
Vector_t rotateFrom(const Vector_t &r) const
virtual void initialize(const ElementBase *ref)
CoordinateSystemTrafo getMisalignment(const std::shared_ptr< Component > &comp) const
size_t getNumberOfEmissionSteps()
T isnan(T x)
isnan function with adjusted return type
std::string::const_iterator iterator_t
ParticleAttrib< int > Bin
CoordinateSystemTrafo inverted() const
void dumpSDDS(PartBunchBase< double, 3 > *beam, Vector_t FDext[], const double &azimuth=-1) const
void calcGammas()
Compute the gammas of all bins.
double getEnergy(Vector_t p, double mass)
virtual void setBinCharge(int bin, double q)
Set the charge of one bin to the value of q and all other to zero.
Quaternion getInitialDirection() const
ParticleAttrib< Vector_t > Bf
ParticleAttrib< double > M
void evenlyDistributeParticles()
Quaternion conjugate() const
Inform & level3(Inform &inf)
std::string::iterator iterator
void timeIntegration1(BorisPusher &pusher)
void setOptionalVariables()
double getEmissionDeltaT()
void get_bounds(Vector_t &rmin, Vector_t &rmax)
StepSizeConfig & advanceToPos(double spos)
static void stopTimer(TimerRef t)
static Communicate * Comm
void setFlagAllParticlesIn(bool p)
#define P_SPATIAL_TRANSFER_TAG
Inform & level1(Inform &inf)
std::string getEnergyString(double energyInMeV, unsigned int precision=3)
std::set< ParticleMatterInteractionHandler * > activeParticleMatterInteractionHandlers_m
T::PETE_Expr_t::PETE_Return_t min(const PETE_Expr< T > &expr, NDIndex< D > &loc)
void push(Vector_t &R, const Vector_t &P, const double &dt) const
PartBunchBase< double, 3 > * itsBunch_m
The bunch of particles to be tracked.
void autophaseCavities(const BorisPusher &pusher)
void selectDT(bool backTrack=false)
unsigned int getLosses() const
virtual ~ParallelTTracker()
void setInPrepState(bool state)
Inform & endl(Inform &inf)
void storeCavityInformation()
Write cavity information from H5 file.
std::set< std::shared_ptr< Component > > value_t
T isinf(T x)
isinf function with adjusted return type
void dumpStats(long long step, bool psDump, bool statDump)
size_t emitParticles(double eZ)
Emit particles in the given bin i.e. copy the particles from the bin structure into the particle cont...
long long getGlobalTrackStep() const
Vector_t transformFrom(const Vector_t &r) const
Track particles or bunches.
CoordinateSystemTrafo getCSTrafoGlobal2Local() const