HepRotation delta() setPhi()
Z these are I think new Just check against the equivalent form by instantiating a general Lor Rot based on a ROtationX and so forth Rotation LorentzBoostX
At least for we will omit so as not to introduce template complications into CLHEP If we can put this back in the LorentzVector h file in the ZOOM area that typedefs LorentzVector from HepLorentzVector And if there is a tremendous desire for this from the CLHEP we can provide this capability be suppying a header file which users can optionally include(Since these are templated global methods, all information can naturally go into a header file which need not be included if these methods are not called.) 26 - Unit 4-Vectors along each axis This takes advantage of ISOcxx which handles all the of places where things like sqrt are found CLHEP has its own congfigure for and till ISOcxx is in place
How the various random distributions are validated The distributions in for example are independently validated By we mean checking that *The algorithm is mathematically correct *The algorithm is properly coded *The compilation of the algorithm is proper for this plaform *There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm and testing that these obey the mathematical properties of the desired distribution For each those we reject if the distribution is sigma away from the proper properties
there is no the time needed for times is not significantly certainly not enough to warrant the additional complication So we simple provide the transform method taking a rotation interface
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateZ CLHEP and PhysicsVectors each have these three and they are identical except that the ZOOM version returns a reference to * this
At least for we will omit so as not to introduce template complications into CLHEP If we can put this back in the LorentzVector h file in the ZOOM area that typedefs LorentzVector from HepLorentzVector And if there is a tremendous desire for this from the CLHEP crowd
ZOOM classes Symbol which is defined in the SpaceVector h backward compatibility header This has the consequence that ThreeVector h is considerably since the plethora of constructors is greatly reduced Spherical coordinate the user can still use the set() methods in spherical coordinates. Except that again the keywords DERGREES RADIANS ETA are not available. Instead
ZOOM classes Symbol pollution
ZOOM classes Symbol which is defined in the SpaceVector h backward compatibility header This has the consequence that ThreeVector h is considerably since the plethora of constructors is greatly reduced Spherical coordinate setting
In alll angles are always treated as measured in RADIANS Spherical coordinate setting mof V in LorentzVector
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateZ CLHEP and PhysicsVectors each have these three and they are identical except that the ZOOM version returns a reference to while in CLHEP they return void Having methods that alter an object return a reference to that object is convenient for certain chained and costs nothing I don t wish to potentially break ZOOM user code for no good so I have made these CLHEP method conform to this convention There are a couple of other CLHEP rotate and which use the void return but since these methods or signatures don t appear in the original ZOOM this can t break any so I leave the void return type alone for those After discussion with A P and I have modified the return types of other CLHEP methods which return void and would by the same reasoning be better returning *this These include rotate and boost methods in LorentzVector h HepLorentzVector explicit and leads to division by zero if this vector has which takes very little time I think the zoom implementation is therefore better by the way
#define ZMthrow(userExcept)
Technical Maintenance Note for CLHEP Random Consequences of seeding JamesRandom with positive seed values greater than In the source code JamesRandom cc
these appear together in RotationInterfaces h As usual
Z these are I think new Just check against the equivalent form by instantiating a general Lor Rot based on a ROtationX and so forth Rotation LorentzBoostZ These are useful and will become part of CLHEP THe boost classes may be in their own header file Inheritance which provide those methods available for GETTING INFORMATION ABOUT generic Rotations and LorentzTransformations We should keep these The proper inheritance is that RI derives from because anything you wish to ask about a LT you could equally well ask about a R From one derives and each of the boosts From RI
we want to make it possible for the user to use the so we provide a few new methods
Z these are I think new Just check against the equivalent form by instantiating a general Lor Rot based on a ROtationX and so forth Rotation LorentzBoost
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateY
the naive Gaussian approximation is inaccurate at a level for turns out to be detectable in a sample of only
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateX
When exceptions are the ZMthrow macro looks we know the try part will throw why not just do
Technical Maintenance Note for CLHEP Random Consequences of seeding JamesRandom with positive seed values greater than In the source code JamesRandom The usual way of seeding a generator is via the default which makes use of the table of and the seed is the xor of a mask which starts with a bit and the seed from the table But it and often supply a seed of more than
we want to make it possible for the user to use the so we provide a few new for example
we want to make it possible for the user to use the set() methods in spherical coordinates. But(see item 4.1) the keywords DERGREES RADIANS ETA are not available in Hep3Vector
HepLorentzVector & boostZ(double beta)
they are gone ZOOM Features Discontinued The following features of the ZOOM package were felt to be extreme overkill These have been after checking that no existing user code was utilizing them
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateZ CLHEP and PhysicsVectors each have these three and they are identical except that the ZOOM version returns a reference to while in CLHEP they return void Having methods that alter an object return a reference to that object is convenient for certain chained and costs nothing I don t wish to potentially break ZOOM user code for no good so I have made these CLHEP method conform to this convention There are a couple of other CLHEP rotate and which use the void return but since these methods or signatures don t appear in the original ZOOM classes
HepRotation and so forth isNear() norm2() rectify() static Rotation row1 row4(To avoid bloat in the code pulled in for programs which don 't use all these features, we split the implementation .cc files. Only isNear() goes into the original Rotation.cc) --------------------------------------- HepAxisAngle and HepEulerAngles classes --------------------------------------- These classes are very useful and simple structures for holding the result of a nice intuituve decomposition of a rotation there is no longer much content in the distinct ZOOM PhysicsVectors library The only content left in the library is the object files representing the various Exception objects When we build the CLHEP classes for the ZOOM we will set up so as to use ZOOM SpaceVector is(but we can disable namespace usage and most of our users do so at this point). What I do is leave Hep3Vector in the global namespace
In alll angles are always treated as measured in RADIANS The full set of original signatures for set are still implemented via the SpaceVector h header for compatibility with ZOOM use Use of UnitVector Some code at Fermilab uses and I have also found some situations where the efficiency can make a significant difference I provide UnitVector as a class for ZOOM users in the zmpv namespace via a file UnitVector h This no longer inherits from SpaceVector
the goal is to keep the overall false rejection probability down at the to level For each validated we discuss here
Z these are I think new Just check against the equivalent form by instantiating a general Lor Rot based on a ROtationX and so forth Rotation LorentzBoostZ These are useful and will become part of CLHEP THe boost classes may be in their own header file Inheritance which provide those methods available for GETTING INFORMATION ABOUT generic Rotations and LorentzTransformations We should keep these The proper inheritance is that RI derives from LTI
ZOOM classes Symbol which is defined in the SpaceVector h backward compatibility header This has the consequence that ThreeVector h is considerably since the plethora of constructors is greatly reduced Spherical coordinate the user can still use the we provide a few new methods
When exceptions are the ZMthrow macro looks we know the try part will throw why not just consider how ZMthrow is typically used
there is no the time needed for times is not significantly certainly not enough to warrant the additional complication So we simple provide the transform method taking a rotation which will break no code But for pure rotations around coordinate axes and boosts along we do provide such methods as rotateZ and boostZ Here the efficiency difference is marked CLHEP has these explicitly We also must keep the technically superfluous rotate(delta, axis) and boost(3 doubles or 3-vector) methods. Split of .cc files I decided it might not be worth it TODO
We have the boost methods returning HepLorentzVector &rather than so things can be chained we feel the boost methods along an axis
it has advantages For I leave the ZMthrows but substitute I replaced ZMthrow with ZMthrowA in this package when will issue its message and I introduce a macro ZMthrowC which I use wherever it seems there is a sensible way to continue processing after reporting the problem we don t want to change the functionallity when this is used in the ZOOM context To retain true ZOOM Exception features
At least for we will omit so as not to introduce template complications into CLHEP If we can put this back in the LorentzVector h file in the ZOOM area that typedefs LorentzVector from HepLorentzVector And if there is a tremendous desire for this from the CLHEP we can provide this capability be suppying a header file which users can optionally include(Since these are templated global methods, all information can naturally go into a header file which need not be included if these methods are not called.) 26 - Unit 4-Vectors along each axis This takes advantage of ISOcxx portability
the default is TimePositive CLHEP always does TimePositive The cost of the flexibility is and mag2 and no other routines are altered Because of I am keeping metric flexibility in the package Pure CLHEP users need never see this m2()
namespace and inside the zmpv namespace it typedef s UnitVector to be HepUnit3Vector The conversion which provide those methods available for GETTING INFORMATION if an object might be either a Rotation or a since RI has methods a routine can be passed a RI &and take because anything you wish to ask about a LT you could equally well ask about a Rotation From one derives Rotation and its special cases RotationX etc We can t derive RotationX from from one derives HepLorentzRotation along with and so forth The Hep classes expressing RI and LTI are Hep3RotationInterface and Hep4RotationInterface
We have the boost methods returning HepLorentzVector &rather than so things can be chained we feel the boost methods along an boostZ in particular
we want to make it possible for the user to use the so instead
Signatures of Hep3Vector::rotate For equivalent ZOOM takes(axis, delta) where CLHEP takes(delta
Signatures of Hep3Vector::rotate For equivalent rotate() methods
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateZ CLHEP and PhysicsVectors each have these three and they are identical except that the ZOOM version returns a reference to while in CLHEP they return void Having methods that alter an object return a reference to that object is convenient for certain chained and costs nothing I don t wish to potentially break ZOOM user code for no good so I have made these CLHEP method conform to this convention There are a couple of other CLHEP rotate and which use the void return but since these methods or signatures don t appear in the original ZOOM this can t break any so I leave the void return type alone for those After discussion with A P and I have modified the return types of other CLHEP methods which return void and would by the same reasoning be better returning *this These include rotate and boost methods in LorentzVector h HepLorentzVector explicit and leads to division by zero if this vector has ee
Z these are I think new Just check against the equivalent form by instantiating a general Lor Rot based on a ROtationX and so forth Rotation Classes
Z these are I think new Just check against the equivalent form by instantiating a general Lor Rot based on a ROtationX and so forth Rotation RotationY
it has advantages For I leave the ZMthrows but substitute I replaced ZMthrow with ZMthrowA in this package when will issue its message and I introduce a macro ZMthrowC which I use wherever it seems there is a sensible way to continue processing after reporting the problem we don t want to change the functionallity when this is used in the ZOOM context To retain true ZOOM Exception we provide in ZMxpv h a define of ENABLE_ZOOM_EXCEPTIONS In CLEHP this is not and ZMthrowA and ZMthrowC become macros that behave as above When we build for ZOOM
At least for we will omit so as not to introduce template complications into CLHEP If we can put this back in the LorentzVector h file in the ZOOM area that typedefs LorentzVector from HepLorentzVector And if there is a tremendous desire for this from the CLHEP we can provide this capability be suppying a header file which users can optionally include(Since these are templated global methods, all information can naturally go into a header file which need not be included if these methods are not called.) 26 - Unit 4-Vectors along each axis This takes advantage of ISOcxx which handles all the of places where things like sqrt are found CLHEP has its own congfigure mechanism
Z these are I think new Just check against the equivalent form by instantiating a general Lor Rot based on a ROtationX and so forth Rotation LorentzBoostZ These are useful and will become part of CLHEP THe boost classes may be in their own header file Inheritance which provide those methods available for GETTING INFORMATION ABOUT generic Rotations and LorentzTransformations We should keep these The proper inheritance is that RI derives from because anything you wish to ask about a LT you could equally well ask about a R From one derives LT
ZOOM classes Symbol which is defined in the SpaceVector h backward compatibility header This has the consequence that ThreeVector h is considerably since the plethora of constructors is greatly reduced Spherical coordinate the user can still use the we provide a few new for setRThetaPhi(double r, double theta, double phi)
Methods applicble to containers of vectors
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateZ CLHEP and PhysicsVectors each have these three and they are identical except that the ZOOM version returns a reference to while in CLHEP they return void Having methods that alter an object return a reference to that object is convenient for certain chained and costs nothing I don t wish to potentially break ZOOM user code for no good so I have made these CLHEP method conform to this convention There are a couple of other CLHEP rotate and which use the void return but since these methods or signatures don t appear in the original ZOOM this can t break any code
virtual double operator()(double argument) const
there is no the time needed for times is not significantly less
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this alone
the default is TimePositive CLHEP always does TimePositive The cost of the flexibility is diff2
this formatted text is the function s string result this method sends the formatted string s to the ostream destination specified when the logger was instantiated as its a code describing if any
user code seldom needs to call this function directly ZMerrno whether or not they are still recorded ZMerrno whether or not they are still since the user counter was last ZMerrno while ZMerrno ZMerrno get() gives a(const pointer to) the latest recorded exception
Issues Concerning the PhysicsVectors CLHEP Vector Merge The merge of ZOOM PhysicsVdectors and the CLHEP Vector package is completed The purpose of this document is to list the major issues that affected the merge of these and where relevant describe the resolutions More detailed documents describe more minor issues General Approach As agreed at the June CLHEP the approach is to combine the features of each ZOOM class with the corresponding CLHEP class expanding the interface to create a single lingua franca of what a I have placed almost all the new features in a separate
the default is TimePositive CLHEP always does TimePositive The cost of the flexibility is small
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateZ CLHEP and PhysicsVectors each have these three and they are identical except that the ZOOM version returns a reference to while in CLHEP they return void Having methods that alter an object return a reference to that object is convenient for certain chained and costs nothing I don t wish to potentially break ZOOM user code for no good so I have made these CLHEP method conform to this convention There are a couple of other CLHEP rotate and which use the void return type
that avoids the design flaw of specialization by virtual non inheritance The entire implementation of necessity no CLHEP const EVERY method of Hep3Vector is present for UnitVector like become quite trivial
We have the boost methods returning HepLorentzVector &rather than so things can be chained we feel the boost methods along an boostZ in really ought to be in the main part of the header ZOOM does several checks to see that the boost vector is not tachyonic we will forego these and use the CLHEP implementations Methods acting on containers of LorentzVectors
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateZ CLHEP and PhysicsVectors each have these three and they are identical except that the ZOOM version returns a reference to while in CLHEP they return void Having methods that alter an object return a reference to that object is convenient for certain chained and costs nothing I don t wish to potentially break ZOOM user code for no good so I have made these CLHEP method conform to this convention There are a couple of other CLHEP rotate and which use the void return but since these methods or signatures don t appear in the original ZOOM this can t break any so I leave the void return type alone for those After discussion with A P and I have modified the return types of other CLHEP methods which return void and would by the same reasoning be better returning *this These include rotate and boost methods in LorentzVector h HepLorentzVector explicit keyword
CLHEP::HepAxisAngle AxisAngle
Z these are I think new Just check against the equivalent form by instantiating a general Lor Rot based on a ROtationX and so forth Rotation LorentzBoostY
they are gone ZOOM Features Discontinued The following features of the ZOOM package were felt to be extreme overkill These have been after checking that no existing user code was utilizing as in SpaceVector v
this pulls in the ZOOM Exception behaviour Thus in our ZOOM people still get the ZOOM Exceptions behaviour they are used to(an absolute requirement for us) -- but pure CLHEP users do not see the Exceptions package at all. The only slight annoyance is that now for ZOOM users CLHEP will depend on Exceptions(and ZMutility) -- where a minimalist would note that only the CLHEP/Vector subpackage needed to depend on these even in ZOOM. The linker is such a minimalist setRThetaPhi(r, theta, phi) setREtaPhi(r
Z these are I think new Just check against the equivalent form by instantiating a general Lor Rot based on a ROtationX and so forth Rotation LorentzBoostZ These are useful and will become part of CLHEP THe boost classes may be in their own header file Inheritance structure
exctest1 cc this occurrence arose from this associated compilation unit
We should separate methods that force the load of the Rotation class For practical that implies that methods like and that as in the ThreeVector class we separate the cc files Also again we have the rotation methods returning HepLorentzVector &rather than void
this formatted text is the function s string result this method sends the formatted string s to the ostream destination specified when the logger was instantiated as its result
Metric selector ZOOM allows the user to set metric as TimePositive or TimeNegative
Issues Concerning the PhysicsVectors CLHEP Vector Merge The merge of ZOOM PhysicsVdectors and the CLHEP Vector package is completed The purpose of this document is to list the major issues that affected the merge of these and where relevant describe the resolutions More detailed documents describe more minor issues General Approach As agreed at the June CLHEP the approach is to combine the features of each ZOOM class with the corresponding CLHEP class expanding the interface to create a single lingua franca of what a I have placed almost all the new features in a second section of the and have created separate cc files for sensible subsets of the methods In if a program uses only the methods found in the original CLHEP very little additional code is linked in Classes The corresponding classes I am not giving up on it eventually being in use
Issues Concerning the PhysicsVectors CLHEP Vector Merge The merge of ZOOM PhysicsVdectors and the CLHEP Vector package is completed The purpose of this document is to list the major issues that affected the merge of these and where relevant describe the resolutions More detailed documents describe more minor issues General Approach As agreed at the June CLHEP the approach is to combine the features of each ZOOM class with the corresponding CLHEP class expanding the interface to create a single lingua franca of what a Hep3Vector(for example) means. We are not forming SpaceVector as an class derived from Hep3Vector and enhancing it in that way. Another rule imposed by the agreement is to avoid using the Exceptions package(even though that will later go into CLHEP for other uses). A desirable goal is to avoid cluttering the interface and enlarging the code linked in when ordinary CLHEP Vector functionallity is used. To this end
In alll angles are always treated as measured in RADIANS Spherical coordinate setting mof V in however
ZOOM classes Symbol which is defined in the SpaceVector h backward compatibility header This has the consequence that ThreeVector h is considerably since the plethora of constructors is greatly reduced Spherical coordinate the user can still use the we provide a few new for example
In alll angles are always treated as measured in RADIANS The full set of original signatures for set are still implemented via the SpaceVector h header for compatibility with ZOOM use Use of UnitVector Some code at Fermilab uses UnitVector
that avoids the design flaw of specialization by virtual non inheritance The entire implementation of necessity no CLHEP const EVERY method of Hep3Vector is present for UnitVector Some
Introduction to the Use of Zoom Exceptions W E last revised Jan Introduction This summary describes the mechanics decided on for creating and throwing a ZMexception as implemented by the zoom Exceptions package Note that all public C symbols used within this Exceptions class begin with the unlikely prefix we use ZMexception as the name of the class from which all other exception classes all ZOOM generated ZMexception classes will use at least ZMx as their name prefix More to avoid internal name the names start with a short string identifying the package
std::complex< double > dot(const SphericalHarmonicCoefficientSet &, const SphericalHarmonicCoefficientSet &)
ZOOM classes Symbol which is defined in the SpaceVector h backward compatibility header This has the consequence that ThreeVector h is considerably simplified
When exceptions are enabled
it has advantages For I leave the ZMthrows but substitute I replaced ZMthrow with ZMthrowA in this package when will issue its message and I introduce a macro ZMthrowC which I use wherever it seems there is a sensible way to continue processing after reporting the problem we don t want to change the functionallity when this is used in the ZOOM context To retain true ZOOM Exception we provide in ZMxpv h a define of ENABLE_ZOOM_EXCEPTIONS In CLEHP this is not defined
HepLorentzVector rotationOf(const HepLorentzVector &vec, const Hep3Vector &axis, double delta)
I could not create a faster method completely accurate that does not require overly large tables and takes a major step up when we cross for several values of but we have applied this with much higher N We validated the main trials It showed no sign of approaching the rejectable p values or errors in mean and sigma the method matches the original algorithm
Issues Concerning the PhysicsVectors CLHEP Vector Merge The merge of ZOOM PhysicsVdectors and the CLHEP Vector package is completed The purpose of this document is to list the major issues that affected the merge of these and where relevant describe the resolutions More detailed documents describe more minor issues General Approach As agreed at the June CLHEP the approach is to combine the features of each ZOOM class with the corresponding CLHEP class expanding the interface to create a single lingua franca of what a I have placed almost all the new features in a second section of the and have created separate cc files for sensible subsets of the methods In particular
the default is TimePositive CLHEP always does TimePositive The cost of the flexibility is and mag2 and no other routines are altered Because of I am keeping metric flexibility in the package Pure CLHEP users need never see this mag2()
std::ofstream output("ranRestoreTest.cout")
Technical Maintenance Note for CLHEP Random Consequences of seeding JamesRandom with positive seed values greater than In the source code JamesRandom The usual way of seeding a generator is via the default which makes use of the table of and the seed is the xor of a mask which starts with a bit and the seed from the table But it and often does
we want to make it possible for the user to use the so we provide a few new for double double phi
this formatted text is the function s string result this method sends the formatted string s to the ostream destination specified when the logger was instantiated as its a code describing what
When exceptions are the ZMthrow macro looks like
there is no the time needed for times is not significantly certainly not enough to warrant the additional complication So we simple provide the transform method taking a rotation which will break no code But for pure rotations around coordinate axes and boosts along axes
Methods applicble to containers of as in std::list< LorentzVector > s
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateZ CLHEP and PhysicsVectors each have these three and they are identical except that the ZOOM version returns a reference to while in CLHEP they return void Having methods that alter an object return a reference to that object is convenient for certain chained and costs nothing I don t wish to potentially break ZOOM user code for no good so I have made these CLHEP method conform to this convention There are a couple of other CLHEP rotate and rotateUz
The given behavior will apply to any exceptions ZMthrow n after the handler has been established Available handlers Here is a list of the five standard handlers that are defined via the Exceptions package Each is accompanied by a brief description of its after become the object of a C throw but will have no further affect on subsequent control flow after be thrown if its severity is ZMexERROR or but be ignored if of a lesser severity Note
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateZ CLHEP and PhysicsVectors each have these three and they are identical except that the ZOOM version returns a reference to while in CLHEP they return void Having methods that alter an object return a reference to that object is convenient for certain chained and costs nothing I don t wish to potentially break ZOOM user code for no good so I have made these CLHEP method conform to this convention There are a couple of other CLHEP rotate and which use the void return but since these methods or signatures don t appear in the original ZOOM this can t break any so I leave the void return type alone for those After discussion with A P and I have modified the return types of other CLHEP methods which return void and would by the same reasoning be better returning *this These include rotate and boost methods in LorentzVector h HepLorentzVector explicit and leads to division by zero if this vector has which takes very little time I think the zoom implementation is therefore better This
The given behavior will apply to any exceptions ZMthrow n after the handler has been established Available handlers Here is a list of the five standard handlers that are defined via the Exceptions package Each is accompanied by a brief description of its behavior
We have the boost methods returning HepLorentzVector &rather than so things can be chained we feel the boost methods along an boostZ in really ought to be in the main part of the header ZOOM does several checks to see that the boost vector is not tachyonic we will forego these and use the CLHEP implementations Methods acting on containers of for list< LorentzVector > s
the default is TimePositive CLHEP always does TimePositive The cost of the flexibility is and mag2 and no other routines are altered Because of I am keeping metric flexibility in the package Pure CLHEP users need never see this and restMass2() for LorentzVector what we call in ZOOM restMass2(). ZOOM does not have a method m2(). So we leave m2 as metric independant
there is no the time needed for times is not significantly certainly not enough to warrant the additional complication So we simple provide the transform method taking a rotation which will break no code But for pure rotations around coordinate axes and boosts along we do provide such methods as rotateZ and boostZ Here the efficiency difference is marked Besides
Z these are I think new Just check against the equivalent form by instantiating a general Lor Rot based on a ROtationX and so forth Rotation RotationZ
How the various random distributions are validated The distributions in for example are independently validated By we mean checking that *The algorithm is mathematically correct *The algorithm is properly coded *The compilation of the algorithm is proper for this plaform *There is no subtle interaction between the algorithm and the random engine used that detectably impacts the distribution This validation must be done without reference to the coded algorithm itself(independent). It must be done by generating some(selectable) number of deviates
bool isLightlike(Scalar epsilon=tolerance) const
it has advantages For now
Application of Rotations and LorentzTransformations to containers of and as in Rotation R
Technical Maintenance Note for CLHEP Random Consequences of seeding JamesRandom with positive seed values greater than In the source code JamesRandom The usual way of seeding a generator is via the default which makes use of the table of and the seed is the xor of a mask which starts with a bit and the seed from the table But it can
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateZ CLHEP and PhysicsVectors each have these three and they are identical except that the ZOOM version returns a reference to while in CLHEP they return void Having methods that alter an object return a reference to that object is convenient for certain chained and costs nothing I don t wish to potentially break ZOOM user code for no good reason
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateZ CLHEP and PhysicsVectors each have these three and they are identical except that the ZOOM version returns a reference to while in CLHEP they return void Having methods that alter an object return a reference to that object is convenient for certain chained and costs nothing I don t wish to potentially break ZOOM user code for no good so I have made these CLHEP method conform to this convention There are a couple of other CLHEP rotate and which use the void return but since these methods or signatures don t appear in the original ZOOM this can t break any so I leave the void return type alone for those After discussion with A P and others
it has advantages For I leave the ZMthrows in
Issues Concerning the PhysicsVectors CLHEP Vector Merge The merge of ZOOM PhysicsVdectors and the CLHEP Vector package is completed The purpose of this document is to list the major issues that affected the merge of these and where relevant describe the resolutions More detailed documents describe more minor issues General Approach As agreed at the June CLHEP the approach is to combine the features of each ZOOM class with the corresponding CLHEP class expanding the interface to create a single lingua franca of what a I have placed almost all the new features in a second section of the and have created separate cc files for sensible subsets of the methods In if a program uses only the methods found in the original CLHEP classes
any side effects of that construction would occur twice The semantics of throw on the other hand
Issues Concerning the PhysicsVectors CLHEP Vector Merge The merge of ZOOM PhysicsVdectors and the CLHEP Vector package is completed The purpose of this document is to list the major issues that affected the merge of these and where relevant describe the resolutions More detailed documents describe more minor issues General Approach As agreed at the June CLHEP the approach is to combine the features of each ZOOM class with the corresponding CLHEP class expanding the interface to create a single lingua franca of what a I have placed almost all the new features in a second section of the header
the naive Gaussian approximation is inaccurate at a level which
At least for we will omit so as not to introduce template complications into CLHEP If necessary
any side effects of that construction would occur twice The semantics of throw x
any side effects of that construction would occur twice The semantics of throw on the other are that x is not constructed an extra time The macro used achievs this
We should separate methods that force the load of the Rotation class For practical purposes
include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/ClhepOutOfSourceBuild.cmake) clhep_ensure_out_of_source_build() cmake_minimum_required(VERSION 2.6) project(CLHEP) set(VERSION 2.1.4.1) set(CMAKE_MODULE_PATH $
often useful for progress reporting and for debugging purposes ZMexWARNING Something unusual has but we have a quite reasonable action to take
#define FUNCTION_OBJECT_IMP(classname)
user code seldom needs to call this function directly ZMerrno whether or not they are still recorded ZMerrno whether or not they are still since the user counter was last ZMerrno name() gives the(string) name of the latest recorded exception
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and angle(in itself quite a task) then douing vector *
namespace and inside the zmpv namespace it typedef s UnitVector to be HepUnit3Vector The conversion which provide those methods available for GETTING INFORMATION if an object might be either a Rotation or a RotationZ
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateZ CLHEP and PhysicsVectors each have these three and they are identical except that the ZOOM version returns a reference to while in CLHEP they return void Having methods that alter an object return a reference to that object is convenient for certain chained operations
Issues Concerning the PhysicsVectors CLHEP Vector Merge The merge of ZOOM PhysicsVdectors and the CLHEP Vector package is completed The purpose of this document is to list the major issues that affected the merge of these and where relevant describe the resolutions More detailed documents describe more minor issues General Approach As agreed at the June CLHEP the approach is to combine the features of each ZOOM class with the corresponding CLHEP class expanding the interface to create a single lingua franca of what a I have placed almost all the new features in a second section of the and have created separate cc files for sensible subsets of the methods In if a program uses only the methods found in the original CLHEP very little additional code is linked in Classes The corresponding classes are
CLHEP::HepEulerAngles EulerAngles
We have the boost methods returning HepLorentzVector &rather than so things can be chained we feel the boost methods along an boostZ in really ought to be in the main part of the header ZOOM does several checks to see that the boost vector is not tachyonic However
most use the Hep3Vector implementations Since UnitVector is not in it may eventually become part of so I chose to parallel the situation for SpaceVector w r t Hep3Vector Thus
we want to make it possible for the user to use the so we provide a few new for double theta
that avoids the design flaw of specialization by virtual non inheritance The entire implementation is(by casting to Hep3Vector to get its implementations) so no additional code need go into the CLHEP library. Since UnitVector is not in CLHEP
namespace and inside the zmpv namespace it typedef s UnitVector to be HepUnit3Vector The conversion which provide those methods available for GETTING INFORMATION ABOUT(but not modifying) generic Rotations and LorentzTransformations. For example
namespace guarded::In ZOOM we had in the inheritance tree classes RotationAboutCoordinateAxis and BoostAlongCoordinateAxis These mainly let us avoid duplication of code but were not useful enought to be worth their complexity cost
We have the boost methods returning HepLorentzVector &rather than so things can be chained Also