the FastJet namespace More...
Namespaces | |
| namespace | gas |
namespace to hold default parameters for the active area spec | |
Classes | |
| class | VoronoiAreaSpec |
| Specification for the computation of the Voronoi jet area. More... | |
| class | AreaDefinition |
| class that holds a generic area definition More... | |
| class | ClusterSequence |
| deals with clustering More... | |
| class | ClusterSequence1GhostPassiveArea |
| Like ClusterSequence with computation of the passive jet area by adding a single ghost. More... | |
| class | ClusterSequenceActiveArea |
| Like ClusterSequence with computation of the active jet area. More... | |
| class | ClusterSequenceActiveAreaExplicitGhosts |
| Like ClusterSequence with computation of the active jet area with the addition of explicit ghosts. More... | |
| class | ClusterSequenceArea |
| General class for user to obtain ClusterSequence with additional area information. More... | |
| class | ClusterSequenceAreaBase |
| base class that sets interface for extensions of ClusterSequence that provide information about the area of each jet More... | |
| class | ClusterSequencePassiveArea |
| Like ClusterSequence with computation of the passive jet area. More... | |
| class | ClusterSequenceStructure |
| Contains any information related to the clustering that should be directly accessible to PseudoJet. More... | |
| class | ClusterSequenceVoronoiArea |
| Like ClusterSequence with computation of the Voronoi jet area. More... | |
| class | CompositeJetStructure |
| The structure for a jet made of pieces. More... | |
| class | Error |
| base class corresponding to errors that will be thrown by fastjet More... | |
| class | GhostedAreaSpec |
| Parameters to configure the computation of jet areas using ghosts. More... | |
| class | JetDefinition |
| class that is intended to hold a full definition of the jet clusterer More... | |
| class | _NoInfo |
| dummy class, used as a default template argument More... | |
| class | NNHInfo |
| template that will help initialise a BJ with a PseudoJet and extra information More... | |
| class | NNHInfo< _NoInfo > |
| Specialisation of NNHInfo for cases where there is no extra info. More... | |
| class | NNH |
| Help solve closest pair problems with generic interparticle and beam distance. More... | |
| class | PseudoJet |
| Class to contain pseudojets, including minimal information of use to to jet-clustering routines. More... | |
| class | PseudoJetPlusInfo |
| a templated extension of PseudoJet that carries extra information More... | |
| class | PseudoJetStructureBase |
| Contains any information related to the clustering that should be directly accessible to PseudoJet. More... | |
| class | RangeDefinition |
| class for holding a range definition specification, given by limits on rapidity and azimuth. More... | |
| class | SelectorWorker |
| default selector worker is an abstract virtual base class More... | |
| class | Selector |
| Class that encodes information about cuts and other selection criteria that can be applied to PseudoJet(s). More... | |
| class | SharedPtr |
| an implementation of C++0x shared pointers (or boost's) More... | |
| class | EtaPhi |
| Shortcut for dealing with eta-phi coordinates. More... | |
| class | BackgroundEstimator |
| Class to estimate the density of the background per unit area. More... | |
| class | Filter |
| Class that helps perform filtering/trimming on jets, and optionally subtraction (if rho > 0). More... | |
| class | FilteredJetStructure |
| Class to contain structure information for a filtered jet. More... | |
| class | Transformer |
| Base (abstract) class for a jet transformer. More... | |
| class | ATLASConePlugin |
| Implementation of the ATLAS Cone (plugin for fastjet v2.4 upwards). More... | |
| class | CMSIterativeConePlugin |
| Implementation of the CMS Iterative Cone (plugin for fastjet v2.4 upwards). More... | |
| class | CDFJetCluPlugin |
| Implementation of the JetClu algorithm from CDF (plugin for fastjet-v2.1 upwards). More... | |
| class | CDFMidPointPlugin |
| Implementation of the MidPoint algorithm from CDF (plugin for fastjet-v2.1 upwards). More... | |
| class | D0RunIIConePlugin |
| Implementation of the D0 Run II Cone (plugin for fastjet v2.1 upwards). More... | |
| class | D0RunIBaseConePlugin |
| D0RunIConePlugin is a plugin for fastjet (v2.4 upwards) that provides an interface to the D0 version of Run-I cone algorithm. More... | |
| class | D0RunIConePlugin |
| A plugin for fastjet (v2.4 upwards) that provides an interface to the D0 version of Run-I cone algorithm. More... | |
| class | D0RunIpre96ConePlugin |
| A plugin for fastjet (v2.4 upwards) that provides an interface to the pre 1996 D0 version of Run-I cone algorithm. More... | |
| class | EECambridgePlugin |
| Implementation of the e+e- Cambridge algorithm (plugin for fastjet v2.4 upwards). More... | |
| class | JadePlugin |
| Implementation of the e+e- Jade algorithm (plugin for fastjet v2.4 upwards). More... | |
| class | NestedDefsPlugin |
| Plugin to run multiple jet definitions successively (plugin for fastjet v2.4 upwards). More... | |
| class | SISConeBaseExtras |
| Class that provides extra information about a SISCone clustering. More... | |
| class | SISConePlugin |
| Implementation of the SISCone algorithm (plugin for fastjet v2.1 upwards). More... | |
| class | SISConeExtras |
| Class that provides extra information about a SISCone clustering. More... | |
| class | SISConeSphericalPlugin |
| Implementation of the spherical version of the SISCone algorithm (plugin for fastjet v2.1 upwards). More... | |
| class | SISConeSphericalExtras |
| Class that provides extra information about a SISCone clustering. More... | |
| class | PxConePlugin |
| Implementation of the PxCone algorithm (plugin for fastjet v2.1 upwards). More... | |
| class | TrackJetPlugin |
| Implementation of the TrackJet algorithm (plugin for fastjet v2.4 upwards). More... | |
Typedefs | |
|
typedef ClusterSequenceActiveAreaExplicitGhosts | ClustSeqActAreaEG |
|
typedef ClusterSequenceVoronoiArea::VoronoiAreaCalc | VAC |
| typedef GhostedAreaSpec | ActiveAreaSpec |
| just provide a typedef for backwards compatibility with programs based on versions 2.0 and 2.1 of fastjet | |
| typedef ClusterSequenceAreaBase | ClusterSequenceWithArea |
| typedef JetAlgorithm | JetFinder |
| make standard Les Houches nomenclature JetAlgorithm (algorithm is general recipe without the parameters) backward-compatible with old JetFinder | |
| typedef integral_type< bool, true > | true_type |
| the bool 'true' value promoted to a type | |
|
typedef integral_type< bool, false > | false_type |
| the bool 'false' value promoted to a type | |
| typedef char(& | __yes_type )[1] |
| typedef char(& | __no_type )[2] |
|
typedef CGAL::Triangulation_vertex_base_with_info_2 < InitialisedInt, K > | Vbb |
|
typedef CGAL::Triangulation_hierarchy_vertex_base_2 < Vbb > | Vb |
|
typedef CGAL::Triangulation_face_base_2 < K > | Fb |
|
typedef CGAL::Triangulation_data_structure_2 < Vb, Fb > | Tds |
|
typedef CGAL::Delaunay_triangulation_2 < K, Tds > | Dt |
|
typedef CGAL::Triangulation_hierarchy_2 < Dt > | Triangulation |
|
typedef Triangulation::Vertex_handle | Vertex_handle |
| typedef Triangulation::Point | Point |
|
typedef Triangulation::Vertex_circulator | Vertex_circulator |
| CGAL Point structure. | |
|
typedef Triangulation::Face_circulator | Face_circulator |
| typedef Triangulation::Face_handle | Face_handle |
Enumerations | |
| enum | AreaType { invalid_area = -1, active_area = 0, active_area_explicit_ghosts = 1, one_ghost_passive_area = 10, passive_area = 11, voronoi_area = 20 } |
the different types of area that are supported | |
| enum | Strategy { N2MinHeapTiled = -4, N2Tiled = -3, N2PoorTiled = -2, N2Plain = -1, N3Dumb = 0, Best = 1, NlnN = 2, NlnN3pi = 3, NlnN4pi = 4, NlnNCam4pi = 14, NlnNCam2pi2R = 13, NlnNCam = 12, plugin_strategy = 999 } |
the various options for the algorithmic strategy to adopt in clustering events with kt and cambridge style algorithms. More... | |
| enum | JetAlgorithm { kt_algorithm = 0, cambridge_algorithm = 1, antikt_algorithm = 2, genkt_algorithm = 3, cambridge_for_passive_algorithm = 11, genkt_for_passive_algorithm = 13, ee_kt_algorithm = 50, ee_genkt_algorithm = 53, plugin_algorithm = 99 } |
the various families of jet-clustering algorithm More... | |
| enum | RecombinationScheme { E_scheme = 0, pt_scheme = 1, pt2_scheme = 2, Et_scheme = 3, Et2_scheme = 4, BIpt_scheme = 5, BIpt2_scheme = 6, external_scheme = 99 } |
the various recombination schemes More... | |
Functions | |
| int | __default_random_generator (int *__iseed) |
| string | fastjet_version_string () |
| return a string containing information about the release | |
| PseudoJet | operator+ (const PseudoJet &jet1, const PseudoJet &jet2) |
| PseudoJet | operator- (const PseudoJet &jet1, const PseudoJet &jet2) |
| PseudoJet | operator* (double coeff, const PseudoJet &jet) |
| PseudoJet | operator* (const PseudoJet &jet, double coeff) |
| PseudoJet | operator/ (const PseudoJet &jet, double coeff) |
| bool | have_same_momentum (const PseudoJet &jeta, const PseudoJet &jetb) |
| returns true if the momenta of the two input jets are identical | |
| PseudoJet | PtYPhiM (double pt, double y, double phi, double m) |
| return a pseudojet with the given pt, y, phi and mass | |
| void | sort_indices (vector< int > &indices, const vector< double > &values) |
| template<class T > | |
| vector< T > | objects_sorted_by_values (const vector< T > &objects, const vector< double > &values) |
| given a vector of values with a one-to-one correspondence with the vector of objects, sort objects into an order such that the associated values would be in increasing order | |
| vector< PseudoJet > | sorted_by_pt (const vector< PseudoJet > &jets) |
| return a vector of jets sorted into decreasing kt2 | |
| vector< PseudoJet > | sorted_by_rapidity (const vector< PseudoJet > &jets) |
| return a vector of jets sorted into increasing rapidity | |
| vector< PseudoJet > | sorted_by_E (const vector< PseudoJet > &jets) |
| return a vector of jets sorted into decreasing energy | |
| vector< PseudoJet > | sorted_by_pz (const vector< PseudoJet > &jets) |
| return a vector of jets sorted into increasing pz | |
| PseudoJet | join (const vector< PseudoJet > &pieces) |
| PseudoJet | join (const PseudoJet &j1) |
| build a MergedJet from a single PseudoJet | |
| PseudoJet | join (const PseudoJet &j1, const PseudoJet &j2) |
| build a MergedJet from 2 PseudoJet | |
| PseudoJet | join (const PseudoJet &j1, const PseudoJet &j2, const PseudoJet &j3) |
| build a MergedJet from 3 PseudoJet | |
| PseudoJet | join (const PseudoJet &j1, const PseudoJet &j2, const PseudoJet &j3, const PseudoJet &j4) |
| build a MergedJet from 4 PseudoJet | |
| Selector | SelectorIdentity () |
| Selector | operator! (const Selector &s) |
| logical not applied on a selector | |
| Selector | operator&& (const Selector &s1, const Selector &s2) |
| logical and between two selectors | |
| Selector | operator|| (const Selector &s1, const Selector &s2) |
| logical or between two selectors | |
| Selector | operator* (const Selector &s1, const Selector &s2) |
| successive application of 2 selectors | |
| Selector | SelectorPtMin (double ptmin) |
| select objects with pt >= ptmin | |
| Selector | SelectorPtMax (double ptmax) |
| select objects with pt <= ptmax | |
| Selector | SelectorPtRange (double ptmin, double ptmax) |
| select objects with ptmin <= pt <= ptmax | |
| Selector | SelectorEtMin (double Etmin) |
| select objects with Et >= Etmin | |
| Selector | SelectorEtMax (double Etmax) |
| select objects with Et <= Etmax | |
| Selector | SelectorEtRange (double Etmin, double Etmax) |
| select objects with Etmin <= Et <= Etmax | |
| Selector | SelectorEMin (double Emin) |
| select objects with E >= Emin | |
| Selector | SelectorEMax (double Emax) |
| select objects with E <= Emax | |
| Selector | SelectorERange (double Emin, double Emax) |
| select objects with Emin <= E <= Emax | |
| Selector | SelectorMMin (double Mmin) |
| select objects with M >= Mmin | |
| Selector | SelectorMMax (double Mmax) |
| select objects with M <= Mmax | |
| Selector | SelectorMRange (double Mmin, double Mmax) |
| select objects with Mmin <= M <= Mmax | |
| Selector | SelectorRapMin (double rapmin) |
| select objects with rap >= rapmin | |
| Selector | SelectorRapMax (double rapmax) |
| select objects with rap <= rapmax | |
| Selector | SelectorRapRange (double rapmin, double rapmax) |
| select objects with rapmin <= rap <= rapmax | |
| Selector | SelectorAbsRapMin (double absrapmin) |
| select objects with |rap| >= absrapmin | |
| Selector | SelectorAbsRapMax (double absrapmax) |
| select objects with |rap| <= absrapmax | |
| Selector | SelectorAbsRapRange (double absrapmin, double absrapmax) |
| select objects with absrapmin <= |rap| <= absrapmax | |
| Selector | SelectorEtaMin (double etamin) |
| select objects with eta >= etamin | |
| Selector | SelectorEtaMax (double etamax) |
| select objects with eta <= etamax | |
| Selector | SelectorEtaRange (double etamin, double etamax) |
| select objects with etamin <= eta <= etamax | |
| Selector | SelectorAbsEtaMin (double absetamin) |
| select objects with |eta| >= absetamin | |
| Selector | SelectorAbsEtaMax (double absetamax) |
| select objects with |eta| <= absetamax | |
| Selector | SelectorAbsEtaRange (double absetamin, double absetamax) |
| select objects with absetamin <= |eta| <= absetamax | |
| Selector | SelectorPhiRange (double phimin, double phimax) |
| select objects with phimin <= phi <= phimax | |
| Selector | SelectorRapPhiRange (double rapmin, double rapmax, double phimin, double phimax) |
| select objects with rapmin <= rap <= rapmax && phimin <= phi <= phimax | |
| Selector | SelectorNHardest (unsigned int n) |
| select the n hardest objects | |
| Selector | SelectorCircle (const double &radius) |
| select objets within a distance 'radius' from the location of the reference jet, set by Selector::set_reference(...) | |
| Selector | SelectorDoughnut (const double &radius_in, const double &radius_out) |
| select objets with distance from the reference jet is between 'radius_in' and 'radius_out'; the reference jet is set by Selector::set_reference(...) | |
| Selector | SelectorStrip (const double &half_width) |
| select objets within a rapidity distance 'half_width' from the location of the reference jet, set by Selector::set_reference(...) | |
| Selector | SelectorRectangle (const double &half_rap_width, const double &half_phi_width) |
| select objets within rapidity distance 'half_rap_width' from the reference jet and azimuthal-angle distance within 'half_phi_width'; the reference jet is set by Selector::set_reference(...) | |
| Selector | SelectorIsPureGhost () |
| select objects that are (or are only made of) ghosts. | |
| Selector | SelectorPtFractionMin (double fraction) |
| select objects that carry at least a fraction "fraction" of the reference jet. | |
| int | scomp (const void *p1, const void *p2) |
| double | dot_product (const PseudoJet &a, const PseudoJet &b) |
| std::vector< PseudoJet > | sorted_by_pt (const std::vector< PseudoJet > &jets) |
| return a vector of jets sorted into decreasing transverse momentum | |
| std::vector< PseudoJet > | sorted_by_rapidity (const std::vector< PseudoJet > &jets) |
| return a vector of jets sorted into increasing rapidity | |
| std::vector< PseudoJet > | sorted_by_E (const std::vector< PseudoJet > &jets) |
| return a vector of jets sorted into decreasing energy | |
| std::vector< PseudoJet > | sorted_by_pz (const std::vector< PseudoJet > &jets) |
| return a vector of jets sorted into increasing pz | |
| void | sort_indices (std::vector< int > &indices, const std::vector< double > &values) |
| sort the indices so that values[indices[0->n-1]] is sorted into increasing order | |
| template<class T > | |
| std::vector< T > | objects_sorted_by_values (const std::vector< T > &objects, const std::vector< double > &values) |
| given a vector of values with a one-to-one correspondence with the vector of objects, sort objects into an order such that the associated values would be in increasing order (but don't actually touch the values vector in the process). | |
| PseudoJet | join (const std::vector< PseudoJet > &pieces) |
| build a "CompositeJet" from the vector of its pieces | |
| template<typename T , typename U > | |
| std::vector< T > | convert_vector_to (const std::vector< U > &in) |
| a helper to copy a vector of PseudoJet's into a vector of PseudoJetPlusInfo This should allow construct like vector<MyPseudoJet> jets = convert_to<MyPseudoJet>(sorted_by_pt(cs.inclusive_jets())); | |
| template<class T , class U > | |
| bool | operator== (SharedPtr< T > const &t, SharedPtr< U > const &u) |
| comparison: equality | |
| template<class T , class U > | |
| bool | operator!= (SharedPtr< T > const &t, SharedPtr< U > const &u) |
| comparison: difference | |
| template<class T , class U > | |
| bool | operator< (SharedPtr< T > const &t, SharedPtr< U > const &u) |
| comparison: orgering | |
| template<class T > | |
| void | swap (SharedPtr< T > &a, SharedPtr< T > &b) |
| swapping | |
| template<class T > | |
| T * | get_pointer (SharedPtr< T > const &t) |
| getting the pointer | |
| bool | floor_ln2_less (unsigned x, unsigned y) |
| returns true if floor(ln_base2(x)) < floor(ln_base2(y)), using Chan's neat trick... | |
| double | norm (const Point p) |
| norm of a vector | |
| double | vector_product (const Point &p1, const Point &p2) |
| 2D vector product | |
| double | scalar_product (const Point &p1, const Point &p2) |
| scalar product | |
| template<class T > | |
| T | deltaPhi (T phi1, T phi2) |
| template<class T > | |
| T | deltaR2 (T eta1, T phi1, T eta2, T phi2) |
Variables | |
| BasicRandom< int > | _G_random_int |
| BasicRandom< double > | _G_random_double |
| const unsigned int | huge_unsigned = 4294967295U |
| const unsigned int | twopow31 = 2147483648U |
| const JetAlgorithm | aachen_algorithm = cambridge_algorithm |
| provide other possible names for the Cambridge/Aachen algorithm? | |
| const JetAlgorithm | cambridge_aachen_algorithm = cambridge_algorithm |
| const double | MaxRap = 1e5 |
| Used to protect against parton-level events where pt can be zero for some partons, giving rapidity=infinity. | |
| const double | pseudojet_invalid_phi = -100.0 |
| default value for phi, meaning it (and rapidity) have yet to be calculated) | |
| const double | pi = 3.141592653589793238462643383279502884197 |
| const double | twopi = 6.283185307179586476925286766559005768394 |
| const double | pisq = 9.869604401089358618834490999876151135314 |
| const double | zeta2 = 1.644934066848226436472415166646025189219 |
| const double | zeta3 = 1.202056903159594285399738161511449990765 |
| const double | eulergamma = 0.577215664901532860606512090082402431042 |
| const double | ln2 = 0.693147180559945309417232121458176568076 |
| const int | INFINITE_VERTEX = -1 |
| const int | NEW_VERTEX = -2 |
| const double | HUGE_DOUBLE = 1e300 |
the FastJet namespace
Order(N^2) clustering.
all the fastjet-related material is put under that namespace
Works for any class BJ that satisfies certain minimal requirements (which are ...?)
| enum fastjet::Strategy |
the various options for the algorithmic strategy to adopt in clustering events with kt and cambridge style algorithms.
Definition at line 50 of file JetDefinition.hh.
{
/// fastest form about 500..10^4
N2MinHeapTiled = -4,
/// fastest from about 50..500
N2Tiled = -3,
/// legacy
N2PoorTiled = -2,
/// fastest below 50
N2Plain = -1,
/// worse even than the usual N^3 algorithms
N3Dumb = 0,
/// automatic selection of the best (based on N)
Best = 1,
/// best of the NlnN variants -- best overall for N>10^4.
/// (Does not work for R>=2pi)
NlnN = 2,
/// legacy N ln N using 3pi coverage of cylinder.
/// (Does not work for R>=2pi)
NlnN3pi = 3,
/// legacy N ln N using 4pi coverage of cylinder
NlnN4pi = 4,
/// Chan's closest pair method (in a variant with 4pi coverage),
/// for use exclusively with the Cambridge algorithm.
/// (Does not work for R>=2pi)
NlnNCam4pi = 14,
/// Chan's closest pair method (in a variant with 2pi+2R coverage),
/// for use exclusively with the Cambridge algorithm.
/// (Does not work for R>=2pi)
NlnNCam2pi2R = 13,
/// Chan's closest pair method (in a variant with 2pi+minimal extra
/// variant), for use exclusively with the Cambridge algorithm.
/// (Does not work for R>=2pi)
NlnNCam = 12, // 2piMultD
/// the plugin has been used...
plugin_strategy = 999
};
the various families of jet-clustering algorithm
Definition at line 91 of file JetDefinition.hh.
{
/// the longitudinally invariant kt algorithm
kt_algorithm=0,
/// the longitudinally invariant variant of the cambridge algorithm
/// (aka Aachen algoithm).
cambridge_algorithm=1,
/// like the k_t but with distance measures
/// dij = min(1/kti^2,1/ktj^2) Delta R_{ij}^2 / R^2
/// diB = 1/kti^2
antikt_algorithm=2,
/// like the k_t but with distance measures
/// dij = min(kti^{2p},ktj^{2p}) Delta R_{ij}^2 / R^2
/// diB = 1/kti^{2p}
/// where p = extra_param()
genkt_algorithm=3,
/// a version of cambridge with a special distance measure for particles
/// whose pt is < extra_param()
cambridge_for_passive_algorithm=11,
/// a version of genkt with a special distance measure for particles
/// whose pt is < extra_param() [relevant for passive areas when p<=0]
genkt_for_passive_algorithm=13,
//.................................................................
/// the e+e- kt algorithm
ee_kt_algorithm=50,
/// the e+e- genkt algorithm (R > 2 and p=1 gives ee_kt)
ee_genkt_algorithm=53,
//.................................................................
/// any plugin algorithm supplied by the user
plugin_algorithm = 99
};
the various recombination schemes
Definition at line 132 of file JetDefinition.hh.
{
/// summing the 4-momenta
E_scheme=0,
/// pt weighted recombination of y,phi (and summing of pt's)
/// with preprocessing to make things massless by rescaling E=|\vec p|
pt_scheme=1,
/// pt^2 weighted recombination of y,phi (and summing of pt's)
/// with preprocessing to make things massless by rescaling E=|\vec p|
pt2_scheme=2,
/// pt weighted recombination of y,phi (and summing of pt's)
/// with preprocessing to make things massless by rescaling |\vec p|->=E
Et_scheme=3,
/// pt^2 weighted recombination of y,phi (and summing of pt's)
/// with preprocessing to make things massless by rescaling |\vec p|->=E
Et2_scheme=4,
/// pt weighted recombination of y,phi (and summing of pt's), with
/// no preprocessing
BIpt_scheme=5,
/// pt^2 weighted recombination of y,phi (and summing of pt's)
/// no preprocessing
BIpt2_scheme=6,
/// for the user's external scheme
external_scheme = 99
};
| std::vector<T> fastjet::objects_sorted_by_values | ( | const std::vector< T > & | objects, | |
| const std::vector< double > & | values | |||
| ) |
given a vector of values with a one-to-one correspondence with the vector of objects, sort objects into an order such that the associated values would be in increasing order (but don't actually touch the values vector in the process).
| PseudoJet fastjet::join | ( | const std::vector< PseudoJet > & | pieces | ) |
build a "CompositeJet" from the vector of its pieces
In this case, E-scheme recombination is assumed to compute the total momentum
| bool fastjet::floor_ln2_less | ( | unsigned | x, | |
| unsigned | y | |||
| ) | [inline] |
returns true if floor(ln_base2(x)) < floor(ln_base2(y)), using Chan's neat trick...
Definition at line 220 of file ClosestPair2D.hh.
References floor_ln2_less().
Referenced by floor_ln2_less().
{
if (x>y) return false;
return (x < (x^y)); // beware of operator precedence...
}
| const double fastjet::MaxRap = 1e5 |
Used to protect against parton-level events where pt can be zero for some partons, giving rapidity=infinity.
KtJet fails in those cases.
Definition at line 53 of file PseudoJet.hh.
Referenced by fastjet::PseudoJet::pseudorapidity().
1.7.1