Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • gpietrzy/Rec
  • nbehling/Rec
  • rrabadan/Rec
  • hyeung/Rec
  • smokhnen/Rec
  • padeken/Rec
  • peilian/Rec
  • lambda-hse/Rec
  • mstahl/Rec
  • kklimasz/Rec
  • mimazure/Rec
  • aszabels/Rec
  • wkrzemie/Rec
  • aalvesju/Rec
  • fkeizer/Rec
  • valassi/Rec
  • raaij/Rec
  • sstahl/Rec
  • jonrob/Rec
  • dcampora/Rec
  • graven/Rec
  • lhcb/Rec
22 results
Show changes
Commits on Source (9)
Hide whitespace changes
Inline Side-by-side
Showing
with 140 additions and 233 deletions
Muon/MuonMatch/src/MuonMatchVeloUTSoA.cpp
View file @ c2f95a6d
......@@ -43,9 +43,8 @@ UTTracks MuonMatchVeloUTSoA::operator()( const EventContext& evtCtx, const UTTra
matched.copy_back<SIMDWrapper::scalar::types>( seeds, t, mask );
if ( m_setQOverP )
matched.store_qOverP<SIMDWrapper::scalar::types::float_v>( matched.size() - 1,
SIMDWrapper::scalar::types::float_v{state.qop}, mask );
if ( m_setQOverP && mask )
matched.scalar()[matched.size() - 1].field<LHCb::Pr::Upstream::Tag::State>().setQOverP( state.qop );
}
m_matchCount += matched.size();
......
Phys/FunctorCore/tests/src/TestFunctors.cpp
View file @ c2f95a6d
......@@ -664,14 +664,14 @@ BOOST_AUTO_TEST_CASE( test_v2_particle_functors ) {
// Generate some composites
using int_v = SIMDWrapper::scalar::int_v;
using float_v = SIMDWrapper::scalar::float_v;
LHCb::Event::Composites threebody{3, 3, unique_id_gen};
LHCb::Event::Composites threebody{unique_id_gen};
for ( auto i = 0; i < ncomposites; ++i ) {
std::array<int_v, 3> child_indices{i, i + 1, 0},
child_zip_ids{input1_family_id, input2_family_id, input1_family_id};
std::vector<LHCb::UniqueIDGenerator::ID<int_v>> child_unique_ids{
unique_id_gen.generate<int_v>(), unique_id_gen.generate<int_v>(), unique_id_gen.generate<int_v>()};
threebody.emplace_back<float_v, int_v>(
threebody.emplace_back<SIMDWrapper::InstructionSet::Scalar, float_v, int_v>(
{} /* pos */, {i * 1.f, i * 2.f, 0.f, 0.f} /* p4 */, 42 /* pid */, 3.f /* chi2 */, 2 /* ndof */,
{} /* pos_cov */, {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f} /* p4_cov */,
{0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f} /* mom_pos_cov */, child_indices, child_zip_ids,
......
Phys/SelAlgorithms/src/CombineTracksSIMD.h
View file @ c2f95a6d
......@@ -377,8 +377,8 @@ namespace SelAlgorithms::CombineTracksSIMD {
auto const momposcov = gain_matrix * poscov.cast_to_mat();
// Actually fill the output storage
tmp_storage.emplace_back( vertex_position, p4, int_v{0} /* parent PID */, chi2, ndof, poscov, p4cov, momposcov,
current_child_indices, current_zip_families, current_unique_ids );
tmp_storage.emplace_back<Backend>( vertex_position, p4, int_v{0} /* parent PID */, chi2, ndof, poscov, p4cov,
momposcov, current_child_indices, current_zip_families, current_unique_ids );
// Return a mask of the validity of the first chunk of tmp_storage
return fit_mask;
}
......@@ -471,8 +471,7 @@ namespace SelAlgorithms::CombineTracksSIMD {
// Prepare the output storage
auto const memResource = LHCb::getMemResource( evtCtx );
std::tuple ret{false,
detail::OutputStorage<N>{N, N, unique_id_gen, Zipping::generateZipIdentifier(), memResource}};
std::tuple ret{false, detail::OutputStorage<N>{unique_id_gen, Zipping::generateZipIdentifier(), memResource}};
// Can't use a structured binding here because we need to capture these
// names in lambdas below (and clang doesn't let you do that...)
auto& filter_pass = std::get<0>( ret );
......@@ -502,7 +501,7 @@ namespace SelAlgorithms::CombineTracksSIMD {
// Temporary storage used as a buffer before the mother cut
// TODO make the scheduler provide a second memory resource that is reset after every algorithm and use that here
detail::OutputStorage<N> tmp_storage{N, N, unique_id_gen, storage.zipIdentifier(), memResource};
detail::OutputStorage<N> tmp_storage{unique_id_gen, storage.zipIdentifier(), memResource};
tmp_storage.reserve( simd_t::size );
auto tmp_storage_view = tmp_storage.template simd<Backend>();
......
Pr/PrAlgorithms/src/PrAddUTHitsTool.cpp
View file @ c2f95a6d
......@@ -281,38 +281,14 @@ namespace LHCb::Pr {
template <typename InputType>
std::array<BoundariesNominal, totUTLayers>
PrAddUTHitsTool::findSectors( const InputType& inputs, MiniStates& filteredStates, float signedReCur ) const {
std::array<LHCb::UT::TrackUtils::ExtrapolatedStates, totUTLayers> extrapStatesArray;
assert( m_geomcache.has_value() );
if constexpr ( std::is_same_v<InputType, LongTracks> ) {
for ( auto& layer : extrapStatesArray ) { layer.reserve( inputs.size() ); }
for ( auto const& track : inputs.simd() ) {
//---Define the tolerance parameters
const auto qoverp = track.qOverP();
const auto pos = track.StatePos( 0 );
const auto dir = track.StateDir( 0 );
const auto bendParam = p_utParam * -signedReCur * qoverp;
const auto overp = abs( qoverp );
const auto xTol = p_xTol + p_xTolSlope.value() * overp;
const auto yTol = p_yTolSlope.value() * overp;
assert( m_geomcache.has_value() );
for ( auto&& [layerIndex, layer] : LHCb::range::enumerate( m_geomcache->layers ) ) {
const auto zLayer = layer.z;
const auto yPredLay = pos.y + ( zLayer - pos.z ) * dir.y;
const auto xPredLay = pos.x + ( zLayer - pos.z ) * dir.x + bendParam * ( zLayer - p_zUTField.value() );
auto eStatesArr = extrapStatesArray[layerIndex].template emplace_back<SIMDWrapper::InstructionSet::Best>();
eStatesArr.template field<LHCb::UT::TrackUtils::ExtStateTag::xLayer>().set( xPredLay );
eStatesArr.template field<LHCb::UT::TrackUtils::ExtStateTag::yLayer>().set( yPredLay );
eStatesArr.template field<LHCb::UT::TrackUtils::ExtStateTag::xTol>().set( xTol );
eStatesArr.template field<LHCb::UT::TrackUtils::ExtStateTag::yTol>().set( yTol );
}
const auto qoverp = track.qOverP();
const auto pos = track.StatePos( 0 );
const auto dir = track.StateDir( 0 );
auto fState = filteredStates.emplace_back<SIMDWrapper::InstructionSet::Best>();
fState.field<LHCb::UT::TrackUtils::MiniStateTag::State>().setPosition( pos.x, pos.y, pos.z );
......@@ -321,31 +297,6 @@ namespace LHCb::Pr {
fState.field<LHCb::UT::TrackUtils::MiniStateTag::index>().set( track.indices() );
}
} else {
for ( auto& layer : extrapStatesArray ) { layer.reserve( simd::size ); }
const auto bendParam = p_utParam * -signedReCur * inputs.qOverP();
const auto overp = abs( inputs.qOverP() );
const auto xTol = p_xTol + p_xTolSlope.value() * overp;
const auto yTol = p_yTolSlope.value() * overp;
assert( m_geomcache.has_value() );
for ( auto&& [layerIndex, layer] : LHCb::range::enumerate( m_geomcache->layers ) ) {
const auto zLayer = layer.z;
const auto yPredLay = inputs.y() + ( zLayer - inputs.z() ) * inputs.ty();
const auto xPredLay =
inputs.x() + ( zLayer - inputs.z() ) * inputs.tx() + bendParam * ( zLayer - p_zUTField.value() );
auto eStatesArr = extrapStatesArray[layerIndex].template emplace_back<SIMDWrapper::InstructionSet::Scalar>();
eStatesArr.template field<LHCb::UT::TrackUtils::ExtStateTag::xLayer>().set( xPredLay );
eStatesArr.template field<LHCb::UT::TrackUtils::ExtStateTag::yLayer>().set( yPredLay );
eStatesArr.template field<LHCb::UT::TrackUtils::ExtStateTag::xTol>().set( xTol );
eStatesArr.template field<LHCb::UT::TrackUtils::ExtStateTag::yTol>().set( yTol );
}
auto fState = filteredStates.emplace_back<SIMDWrapper::InstructionSet::Scalar>();
fState.field<LHCb::UT::TrackUtils::MiniStateTag::State>().setPosition( inputs.x(), inputs.y(), inputs.z() );
fState.field<LHCb::UT::TrackUtils::MiniStateTag::State>().setDirection( inputs.tx(), inputs.ty() );
......@@ -354,10 +305,25 @@ namespace LHCb::Pr {
}
auto compBoundsArray =
LHCb::UTDAQ::findAllSectors<BoundariesNominal, LHCb::UT::TrackUtils::BoundariesNominalTag::types,
LHCb::UT::TrackUtils::maxNumRowsBoundariesNominal,
LHCb::UT::TrackUtils::maxNumColsBoundariesNominal>( extrapStatesArray,
filteredStates, *m_geomcache );
LHCb::UTDAQ::findAllSectorsExtrap<BoundariesNominal, LHCb::UT::TrackUtils::BoundariesNominalTag::types,
LHCb::UT::TrackUtils::maxNumRowsBoundariesNominal,
LHCb::UT::TrackUtils::maxNumColsBoundariesNominal>(
filteredStates, *m_geomcache,
[&]( int layerIndex, simd::float_v x, simd::float_v y, simd::float_v z, simd::float_v tx, simd::float_v ty,
simd::float_v qop ) {
const auto bendParam = p_utParam * -signedReCur * qop;
const auto overp = abs( qop );
const simd::float_v xTol = p_xTol + p_xTolSlope.value() * overp;
const simd::float_v yTol = p_yTolSlope.value() * overp;
const simd::float_v zLayer{m_geomcache->layers[layerIndex].z};
const simd::float_v dxDy{m_geomcache->layers[layerIndex].dxDy};
const simd::float_v xLayer = x + ( zLayer - z ) * tx + bendParam * ( zLayer - p_zUTField.value() );
const simd::float_v yLayer = y + ( zLayer - z ) * ty;
return std::make_tuple( xLayer, yLayer, xTol, yTol );
} );
return compBoundsArray;
}
......
Pr/PrAlgorithms/src/PrForwardTracking.cpp
View file @ c2f95a6d
......@@ -1537,8 +1537,7 @@ namespace LHCb::Pr::Forward {
const auto encodedPlaneCntNewFlag = encodedPlaneCnt | encodedPlaneNumber;
// remember: the first nDiffPlanesBits (8) encode the number of different planes
// so let's simply check if we added a flag, and if so, add 1 to number of diff planes
const auto newEncodedPlaneCnt =
encodedPlaneCntNewFlag + select( encodedPlaneCnt < encodedPlaneCntNewFlag, simd::int_v{1}, 0 );
const auto newEncodedPlaneCnt = encodedPlaneCntNewFlag + ( encodedPlaneCnt < encodedPlaneCntNewFlag );
const auto binNumberBase = SIMDWrapper::to_array( binNumber );
const auto planeCntBase = SIMDWrapper::to_array( newEncodedPlaneCnt );
......@@ -1617,8 +1616,7 @@ namespace LHCb::Pr::Forward {
const auto binNumber = calculateBinNumber( projHit, i, maxIdx );
const auto encodedPlaneCnt = gather_planes( binNumber );
const auto encodedPlaneCntNewFlag = encodedPlaneCnt | encodedPlaneNumber;
const auto newEncodedPlaneCnt =
encodedPlaneCntNewFlag + select( encodedPlaneCnt < encodedPlaneCntNewFlag, simd::int_v{1}, 0 );
const auto newEncodedPlaneCnt = encodedPlaneCntNewFlag + ( encodedPlaneCnt < encodedPlaneCntNewFlag );
scatter( m_planeCounter.data(), binNumber, newEncodedPlaneCnt );
} // end of loop over hits
} // end of loop over zones
......
Pr/PrAlgorithms/src/PrMatchNN.cpp
View file @ c2f95a6d
......@@ -338,32 +338,27 @@ LHCb::Pr::Long::Tracks PrMatchNN::makeTracks( const LHCb::Pr::Velo::Tracks& v
auto const seediter = seeds.scalar();
auto const veloiter = velos.scalar();
for ( const auto match : matches ) {
auto currentsize = result.size();
result.resize( currentsize + 1 );
//== copy LHCbIDs
auto const oTrack = result.emplace_back<SIMDWrapper::InstructionSet::Scalar>();
auto const seed_track = seediter[match.sTr()];
auto const n_fthits = seed_track.nHits();
auto const velo_track = veloiter[match.vTr()];
auto const n_vphits = velo_track.nHits();
result.store<TracksTag::trackVP>( currentsize, I{match.vTr()} );
result.store<TracksTag::trackUT>( currentsize, I{-1} );
result.store<TracksTag::trackSeed>( currentsize, I{match.sTr()} );
result.store<TracksTag::nVPHits>( currentsize, n_vphits );
result.store<TracksTag::nUTHits>( currentsize, I{0} );
result.store<TracksTag::nFTHits>( currentsize, n_fthits );
oTrack.field<TracksTag::trackVP>().set( match.vTr() );
oTrack.field<TracksTag::trackUT>().set( -1 );
oTrack.field<TracksTag::trackSeed>().set( match.sTr() );
oTrack.field<TracksTag::nVPHits>().set( n_vphits );
oTrack.field<TracksTag::nUTHits>().set( 0 );
oTrack.field<TracksTag::nFTHits>().set( n_fthits );
for ( auto idx{0}; idx < n_vphits.cast(); ++idx ) {
result.store_vp_index( currentsize, idx, velo_track.vp_index( idx ) );
result.store_lhcbID( currentsize, idx,
LHCb::Event::lhcbid_v<SIMDWrapper::scalar::types>{velo_track.lhcbID( idx )} );
oTrack.field<TracksTag::vp_indices>( idx ).set( velo_track.vp_index( idx ) );
oTrack.field<TracksTag::lhcbIDs>( idx ).setLHCbID( velo_track.lhcbID( idx ) );
}
for ( auto idx{0}; idx < n_fthits.cast(); ++idx ) {
auto const id = n_vphits.cast() + idx;
result.store_ft_index( currentsize, idx, seed_track.ft_index( idx ) );
result.store_lhcbID( currentsize, id,
seed_track.template field<LHCb::Pr::Seeding::Tag::lhcbIDs>( idx ).lhcbID() );
oTrack.field<TracksTag::ft_indices>( idx ).set( seed_track.ft_index( idx ) );
oTrack.field<TracksTag::lhcbIDs>( id ).setLHCbID(
seed_track.template field<LHCb::Pr::Seeding::Tag::lhcbIDs>( idx ).lhcbID() );
}
//== get Velo and T states at the usual pattern reco positions
......@@ -388,16 +383,14 @@ LHCb::Pr::Long::Tracks PrMatchNN::makeTracks( const LHCb::Pr::Velo::Tracks& v
// store end of VELO state
const F qop = float( qOverP );
result.store_qOverP( currentsize, 0, qop );
auto velopos = Vec3<F>( state_endvelo.x(), state_endvelo.y(), state_endvelo.z() );
auto velodir = Vec3<F>( state_endvelo.tx(), state_endvelo.ty(), 1.f );
result.store_StatePosDir( currentsize, 0, velopos, velodir );
oTrack.field<TracksTag::States>( 0 ).setPosition( state_endvelo.x(), state_endvelo.y(), state_endvelo.z() );
oTrack.field<TracksTag::States>( 0 ).setDirection( state_endvelo.tx(), state_endvelo.ty() );
oTrack.field<TracksTag::States>( 0 ).setQOverP( qop );
// store end of T state
result.store_qOverP( currentsize, 1, qop );
auto pos = Vec3<F>( state_endT.x(), state_endT.y(), state_endT.z() );
auto dir = Vec3<F>( state_endT.tx(), state_endT.ty(), 1.f );
result.store_StatePosDir( currentsize, 1, pos, dir );
oTrack.field<TracksTag::States>( 1 ).setPosition( state_endT.x(), state_endT.y(), state_endT.z() );
oTrack.field<TracksTag::States>( 1 ).setDirection( state_endT.tx(), state_endT.ty() );
oTrack.field<TracksTag::States>( 1 ).setQOverP( qop );
}
return result;
......
Pr/PrAlgorithms/src/PrStoreUTHit.cpp
View file @ c2f95a6d
......@@ -83,9 +83,9 @@ namespace LHCb::Pr::UT {
} );
}
HANDLER operator()( const EventContext& /*evtCtx*/, const LHCb::RawBank::View& tBanks,
HANDLER operator()( const EventContext& evtCtx, const LHCb::RawBank::View& tBanks,
const UTGeomCache& cache ) const override {
HANDLER hitHandler{};
HANDLER hitHandler{LHCb::getMemResource( evtCtx )};
hitHandler.reserve( 10000 );
try {
......
Pr/PrAlgorithms/src/PrUpstreamFromVelo.cpp
View file @ c2f95a6d
......@@ -32,10 +32,9 @@ namespace Pr {
TracksUT operator()( TracksVP const& inputTracks ) const override {
using dType = SIMDWrapper::best::types;
using I = dType::int_v;
using F = dType::float_v;
TracksUT outputTracks{&inputTracks};
outputTracks.resize( inputTracks.size() );
outputTracks.reserve( inputTracks.size() );
float invAssumedPT{1.f / m_assumedPT};
for ( auto const& track : inputTracks.simd() ) {
auto mask = track.loop_mask();
......@@ -47,29 +46,16 @@ namespace Pr {
auto txy2 = dir.x * dir.x + dir.y * dir.y;
F const qop = invAssumedPT * sqrt( txy2 / ( 1 + txy2 ) );
auto oTrack = outputTracks.compress_back<SIMDWrapper::InstructionSet::Best>( mask );
oTrack.template field<TracksTag::trackVP>().set( track.indices() );
oTrack.field<TracksTag::nVPHits>().set( I{0} );
oTrack.field<TracksTag::nUTHits>().set( I{0} );
auto oTrack = outputTracks.compress_back( mask );
oTrack.field<TracksTag::trackVP>().set( track.indices() );
oTrack.field<TracksTag::nVPHits>().set( 0 );
oTrack.field<TracksTag::nUTHits>().set( 0 );
oTrack.field<TracksTag::State>().setQOverP( qop );
oTrack.field<TracksTag::State>().setPosition( pos );
oTrack.field<TracksTag::State>().setDirection( dir );
oTrack.field<TracksTag::StateCovX>( LHCb::Pr::Upstream::CovXVector::x_x ).set( cov.x );
oTrack.field<TracksTag::StateCovX>( LHCb::Pr::Upstream::CovXVector::x_tx ).set( cov.y );
oTrack.field<TracksTag::StateCovX>( LHCb::Pr::Upstream::CovXVector::tx_tx ).set( cov.z );
oTrack.field<TracksTag::vp_indices>( 0 ).set( I{0} );
oTrack.field<TracksTag::lhcbIDs>( 0 ).setLHCbID( LHCb::Event::lhcbid_v<dType>( I{0} ) );
/*
outputTracks.store<TracksTag::trackVP>( track.offset(), track.indices(), mask );
outputTracks.store<TracksTag::nVPHits>( track.offset(), I{0}, mask );
outputTracks.store<TracksTag::nUTHits>( track.offset(), I{0}, mask );
outputTracks.store_qOverP( track.offset(), qop, mask );
outputTracks.store_StatePosDir( track.offset(), pos, dir, mask );
outputTracks.store_StateCovX( track.offset(), cov, mask );
outputTracks.store_vp_index( track.offset(), 0, I{0}, mask );
outputTracks.store_lhcbID( track.offset(), 0, I{0}, mask );
*/
}
return outputTracks;
}
......
Pr/PrKernel/include/PrKernel/PrUTHitHandler.h
View file @ c2f95a6d
......@@ -41,6 +41,8 @@ namespace LHCb::Pr::UT {
public:
using allocator_type = LHCb::Pr::UT::Hits::allocator_type;
HitHandler( allocator_type alloc = {} ) : m_hits{Zipping::generateZipIdentifier(), alloc} {}
// Method to add Hit in the container
// This should be changed to float, but needs an adaptation of "DeUTSector"
void AddHit( const DeUTSector* aSector, unsigned int fullChanIdx, unsigned int strip, double fracStrip,
......
Pr/PrPixel/src/VeloClusterTrackingSIMD.cpp
View file @ c2f95a6d
......@@ -397,7 +397,8 @@ namespace LHCb::Pr::Velo {
}
}
void TrackSeeding( HitsPlane* P0, HitsPlane* P1, HitsPlane* P2, LightTracksSoA* tracks ) {
__attribute__( ( flatten ) ) void TrackSeeding( HitsPlane* P0, HitsPlane* P1, HitsPlane* P2,
LightTracksSoA* tracks ) {
using simd = SIMDWrapper::avx256::types;
using I = simd::int_v;
using F = simd::float_v;
......@@ -478,25 +479,16 @@ namespace LHCb::Pr::Velo {
removeHits( P0, bestH0, vh0 );
removeHits( P2, bestH0, vh2 );
int i = tracks->size();
tracks->resize( i + simd::popcount( bestH0 ) );
tracks->store<LightTrackTag::sumScatter>( i, bestFit, bestH0 );
tracks->store<LightTrackTag::p0>( i, 0, bestP0.x, bestH0 );
tracks->store<LightTrackTag::p0>( i, 1, bestP0.y, bestH0 );
tracks->store<LightTrackTag::p0>( i, 2, bestP0.z, bestH0 );
tracks->store<LightTrackTag::p1>( i, 0, p1.x, bestH0 );
tracks->store<LightTrackTag::p1>( i, 1, p1.y, bestH0 );
tracks->store<LightTrackTag::p1>( i, 2, p1.z, bestH0 );
tracks->store<LightTrackTag::p2>( i, 0, bestP2.x, bestH0 );
tracks->store<LightTrackTag::p2>( i, 1, bestP2.y, bestH0 );
tracks->store<LightTrackTag::p2>( i, 2, bestP2.z, bestH0 );
tracks->store<LightTrackTag::nHits>( i, I( 3 ) );
tracks->store<LightTrackTag::skipped>( i, I( 0 ) );
tracks->store<LightTrackTag::hit>( i, 0, vh0, bestH0 );
tracks->store<LightTrackTag::hit>( i, 1, vh1, bestH0 );
tracks->store<LightTrackTag::hit>( i, 2, vh2, bestH0 );
auto const track = tracks->compress_back( bestH0 );
track.field<LightTrackTag::sumScatter>().set( bestFit );
track.field<LightTrackTag::p0>().set( bestP0 );
track.field<LightTrackTag::p1>().set( p1 );
track.field<LightTrackTag::p2>().set( bestP2 );
track.field<LightTrackTag::nHits>().set( 3 );
track.field<LightTrackTag::skipped>().set( 0 );
track.field<LightTrackTag::hit>( 0 ).set( vh0 );
track.field<LightTrackTag::hit>( 1 ).set( vh1 );
track.field<LightTrackTag::hit>( 2 ).set( vh2 );
} // h1
}
......@@ -913,7 +905,6 @@ namespace LHCb::Pr::Velo {
bwd.template field<TracksTag::lhcbIDs>( h ).setLHCbID( id );
}
bwd.template field<TracksTag::States>( 0 ).set( 1.f, 1.f, 1.f, tx, ty );
bwd.setStateCovXY( 1, Vec3<F>( 100.f, 0.f, 1.f ), Vec3<F>( 100.f, 0.f, 1.f ) ); // avoid NAN in chechers
// Store forward tracks
auto forwards = ( !backwards ) && loop_mask;
......@@ -930,8 +921,7 @@ namespace LHCb::Pr::Velo {
fwd.template field<TracksTag::States>( 1 ).set( x0 + StateParameters::ZEndVelo * tx,
y0 + StateParameters::ZEndVelo * ty, StateParameters::ZEndVelo,
tx, ty );
fwd.setStateCovXY( 1, Vec3<F>( 100.f, 0.f, 1.f ), Vec3<F>( 100.f, 0.f, 1.f ) ); // avoid NAN in chechers
} // loop all tracks
} // loop all tracks
// Fit forwards
for ( auto const& track : tracksForward.simd() ) {
......@@ -944,6 +934,7 @@ namespace LHCb::Pr::Velo {
track.StatePosDir( 0 ).setPosition( closestToBeam.pos() );
track.StatePosDir( 0 ).setDirection( closestToBeam.dir() );
track.setStateCovXY( 0, closestToBeam.covX(), closestToBeam.covY() );
track.setStateCovXY( 1, Vec3<F>( 100.f, 0.f, 1.f ), Vec3<F>( 100.f, 0.f, 1.f ) ); // avoid NAN in chechers
}
// Fit backwards
for ( auto const& track : tracksBackward.simd() ) {
......@@ -956,6 +947,7 @@ namespace LHCb::Pr::Velo {
track.StatePosDir( 0 ).setPosition( closestToBeam.pos() );
track.StatePosDir( 0 ).setDirection( closestToBeam.dir() );
track.setStateCovXY( 0, closestToBeam.covX(), closestToBeam.covY() );
track.setStateCovXY( 1, Vec3<F>( 100.f, 0.f, 1.f ), Vec3<F>( 100.f, 0.f, 1.f ) ); // avoid NAN in chechers
}
m_nbClustersCounter += hits.size();
m_nbTracksCounter += tracks.size();
......
Pr/PrVeloUT/src/PrVeloUT.cpp
View file @ c2f95a6d
......@@ -221,9 +221,6 @@ namespace LHCb::Pr {
LHCb::UT::TrackUtils::MiniStates getStates( const Velo::Tracks& inputTracks, Upstream::Tracks& outputTracks ) const;
std::array<LHCb::UT::TrackUtils::ExtrapolatedStates, totalUTLayers>
extrapStates( const LHCb::UT::TrackUtils::MiniStates& filteredStates, const UTDAQ::GeomCache& geom ) const;
bool getHitsScalar( const LHCb::Pr::UT::HitHandler& hh, const LHCb::UT::TrackUtils::MiniStates& filteredStates,
const std::array<LHCb::UT::TrackUtils::BoundariesNominal, 4>& compBoundsArray,
LHCb::Pr::UT::Mut::Hits& hitsInLayers, const std::size_t t,
......@@ -572,15 +569,38 @@ namespace LHCb::Pr {
LHCb::UT::TrackUtils::MiniStates filteredStates = getStates( inputTracks, outputTracks );
std::array<LHCb::UT::TrackUtils::ExtrapolatedStates, 4> extrapStatesArray =
extrapStates( filteredStates, geometry );
simd::float_v invMinPt = 1.0f / m_minPT.value();
simd::float_v invMinMomentum = 1.0f / m_minMomentum.value();
// -- Used for the calculation of the size of the search windows
constexpr const std::array<float, totalUTLayers> normFact{0.95f, 1.0f, 1.36f, 1.41f};
auto compBoundsArray = LHCb::UTDAQ::findAllSectors<
auto compBoundsArray = LHCb::UTDAQ::findAllSectorsExtrap<
LHCb::UT::TrackUtils::BoundariesNominal, LHCb::UT::TrackUtils::BoundariesNominalTag::types,
LHCb::UT::TrackUtils::maxNumRowsBoundariesNominal, LHCb::UT::TrackUtils::maxNumColsBoundariesNominal>(
extrapStatesArray, filteredStates, geometry, m_minLayers );
std::array<LHCb::Pr::UT::Mut::Hits, batchSize> hitsInLayers;
filteredStates, geometry,
[&]( int layerIndex, simd::float_v x, simd::float_v y, simd::float_v z, simd::float_v tx, simd::float_v ty,
simd::float_v ) {
// -- this 0.002 seems a little odd...
const simd::float_v theta = max( 0.002f, sqrt( tx * tx + ty * ty ) );
const simd::float_v invMinMom = min( invMinPt * theta, invMinMomentum );
const simd::float_v xTol =
abs( m_distToMomentum * invMinMom * normFact[layerIndex] ) - abs( tx ) * m_intraLayerDist.value();
const simd::float_v yTol = m_yTol.value() + m_yTolSlope.value() * xTol;
const simd::float_v zGeo{geometry.layers[layerIndex].z};
const simd::float_v dxDy{geometry.layers[layerIndex].dxDy};
const simd::float_v yAtZ = y + ty * ( zGeo - z );
const simd::float_v xLayer = x + tx * ( zGeo - z );
const simd::float_v yLayer = yAtZ + yTol * dxDy;
return std::make_tuple( xLayer, yLayer, xTol, yTol );
},
m_minLayers );
auto hitsInLayers = LHCb::make_object_array<LHCb::Pr::UT::Mut::Hits, batchSize>( Zipping::generateZipIdentifier(),
LHCb::getMemResource( evtCtx ) );
for ( auto& hits : hitsInLayers ) { hits.reserve( 32 ); }
ProtoTracks pTracks;
......@@ -650,11 +670,12 @@ namespace LHCb::Pr {
//=============================================================================
// Get the state, do some cuts
//=============================================================================
LHCb::UT::TrackUtils::MiniStates VeloUT::getStates( const Velo::Tracks& inputTracks,
Upstream::Tracks& outputTracks ) const {
__attribute__( ( flatten ) ) LHCb::UT::TrackUtils::MiniStates
VeloUT::getStates( const Velo::Tracks& inputTracks, Upstream::Tracks& outputTracks ) const {
const int EndVelo = 1;
LHCb::UT::TrackUtils::MiniStates filteredStates;
LHCb::UT::TrackUtils::MiniStates filteredStates{Zipping::generateZipIdentifier(),
{inputTracks.get_allocator().resource()}};
filteredStates.reserve( inputTracks.size() );
const auto centralHoleR2 = simd::float_v{m_centralHoleSize * m_centralHoleSize};
......@@ -682,76 +703,27 @@ namespace LHCb::Pr {
fState.field<LHCb::UT::TrackUtils::MiniStateTag::index>().set( trackVP );
if ( m_passTracks ) {
auto outMask = loopMask && passHoleMask; // not sure if correct...
auto i = outputTracks.size();
outputTracks.resize( i + simd::popcount( outMask ) );
outputTracks.store<TracksTag::trackVP>( i, velotrack.indices(), outMask );
outputTracks.store_qOverP( i, simd::float_v{0.f}, outMask );
outputTracks.store<TracksTag::nUTHits>( i, simd::int_v{0}, outMask );
outputTracks.store<TracksTag::nVPHits>( i, velotrack.nHits(), outMask );
outputTracks.store_StatePosDir( i, pos, dir, outMask );
outputTracks.store_StateCovX( i, covX, outMask );
auto const track = outputTracks.compress_back( outMask );
track.field<TracksTag::trackVP>().set( velotrack.indices() );
track.field<TracksTag::State>().setQOverP( 0.f );
track.field<TracksTag::State>().setPosition( pos );
track.field<TracksTag::State>().setDirection( dir );
track.field<TracksTag::nUTHits>().set( 0 );
track.field<TracksTag::nVPHits>().set( velotrack.nHits() );
track.field<TracksTag::StateCovX>( 0 ).set( covX.x );
track.field<TracksTag::StateCovX>( 1 ).set( covX.y );
track.field<TracksTag::StateCovX>( 2 ).set( covX.z );
for ( int idx = 0; idx < velotrack.nHits().hmax( outMask ); ++idx ) {
outputTracks.store_vp_index( i, idx, velotrack.vp_index( idx ), outMask );
track.field<TracksTag::vp_indices>( idx ).set( velotrack.vp_index( idx ) );
track.field<TracksTag::lhcbIDs>( idx ).setLHCbID( velotrack.lhcbID( idx ) );
}
}
}
return filteredStates;
}
//=============================================================================
// Extrapolate the states
//=============================================================================
std::array<LHCb::UT::TrackUtils::ExtrapolatedStates, totalUTLayers>
VeloUT::extrapStates( const LHCb::UT::TrackUtils::MiniStates& filteredStates, const UTDAQ::GeomCache& geom ) const {
std::array<LHCb::UT::TrackUtils::ExtrapolatedStates, totalUTLayers> eStatesArray;
simd::float_v invMinPt = 1.0f / m_minPT.value();
simd::float_v invMinMomentum = 1.0f / m_minMomentum.value();
for ( int layerIndex = 0; layerIndex < totalUTLayers; ++layerIndex )
eStatesArray[layerIndex].reserve( filteredStates.size() );
// -- Used for the calculation of the size of the search windows
constexpr const std::array<float, totalUTLayers> normFact{0.95f, 1.0f, 1.36f, 1.41f};
for ( const auto& fState : filteredStates.simd() ) {
const auto x = fState.get<LHCb::UT::TrackUtils::MiniStateTag::State>().x();
const auto y = fState.get<LHCb::UT::TrackUtils::MiniStateTag::State>().y();
const auto z = fState.get<LHCb::UT::TrackUtils::MiniStateTag::State>().z();
const auto tx = fState.get<LHCb::UT::TrackUtils::MiniStateTag::State>().tx();
const auto ty = fState.get<LHCb::UT::TrackUtils::MiniStateTag::State>().ty();
// -- this 0.002 seems a little odd...
const simd::float_v theta = max( 0.002f, sqrt( tx * tx + ty * ty ) );
const simd::float_v invMinMom = min( invMinPt * theta, invMinMomentum );
for ( int layerIndex = 0; layerIndex < totalUTLayers; ++layerIndex ) {
const simd::float_v xTol =
abs( m_distToMomentum * invMinMom * normFact[layerIndex] ) - abs( tx ) * m_intraLayerDist.value();
const simd::float_v yTol = m_yTol.value() + m_yTolSlope.value() * xTol;
const simd::float_v zGeo{geom.layers[layerIndex].z};
const simd::float_v dxDy{geom.layers[layerIndex].dxDy};
const simd::float_v yAtZ = y + ty * ( zGeo - z );
const simd::float_v xLayer = x + tx * ( zGeo - z );
const simd::float_v yLayer = yAtZ + yTol * dxDy;
auto eStatesArr =
eStatesArray[layerIndex].emplace_back<SIMDWrapper::InstructionSet::Best>( filteredStates.size() );
eStatesArr.field<LHCb::UT::TrackUtils::ExtStateTag::xLayer>().set( xLayer );
eStatesArr.field<LHCb::UT::TrackUtils::ExtStateTag::yLayer>().set( yLayer );
eStatesArr.field<LHCb::UT::TrackUtils::ExtStateTag::xTol>().set( xTol );
eStatesArr.field<LHCb::UT::TrackUtils::ExtStateTag::yTol>().set( yTol );
}
}
return eStatesArray;
}
//=============================================================================
// Find the hits
//=============================================================================
......@@ -994,7 +966,7 @@ namespace LHCb::Pr {
// Create the Velo-UT tracks
//=========================================================================
template <typename BdlTable>
inline __attribute__( ( always_inline ) ) void VeloUT::prepareOutputTrackSIMD(
inline __attribute__( ( always_inline ) ) __attribute__( ( flatten ) ) void VeloUT::prepareOutputTrackSIMD(
const ProtoTracks& protoTracks, const std::array<LHCb::Pr::UT::Mut::Hits, batchSize>& hitsInLayers,
Upstream::Tracks& outputTracks, const Velo::Tracks& inputTracks, const BdlTable& bdlTable ) const {
......@@ -1120,23 +1092,23 @@ namespace LHCb::Pr {
const auto EndVelo = 1;
const auto currentsize = outputTracks.size();
outputTracks.resize( currentsize + simd::popcount( finalMask ) );
outputTracks.store_qOverP( currentsize, finalQoP, finalMask );
outputTracks.store<TracksTag::trackVP>( currentsize, ancestor, finalMask );
outputTracks.store<TracksTag::nVPHits>( currentsize, velo_ancestor.nHits(), finalMask );
outputTracks.store_StatePosDir( currentsize, velo_ancestor.StatePos( EndVelo ), velo_ancestor.StateDir( EndVelo ),
finalMask );
outputTracks.store_StateCovX( currentsize, velo_ancestor.StateCovX( EndVelo ), finalMask );
// store velo index and lhcbids
for ( auto idx = 0; idx < velo_ancestor.nHits().hmax( finalMask ); ++idx ) {
outputTracks.store_vp_index( currentsize, idx, velo_ancestor.vp_index( idx ), finalMask );
outputTracks.store_lhcbID<simd>( currentsize, idx, LHCb::Event::lhcbid_v<simd>( velo_ancestor.lhcbID( idx ) ),
finalMask );
const auto oTrack = outputTracks.compress_back( finalMask );
oTrack.field<TracksTag::trackVP>().set( ancestor );
oTrack.field<TracksTag::State>().setQOverP( finalQoP );
oTrack.field<TracksTag::State>().setPosition( velo_ancestor.StatePos( EndVelo ) );
oTrack.field<TracksTag::State>().setDirection( velo_ancestor.StateDir( EndVelo ) );
oTrack.field<TracksTag::nVPHits>().set( velo_ancestor.nHits() );
auto covX = velo_ancestor.StateCovX( EndVelo );
oTrack.field<TracksTag::StateCovX>( 0 ).set( covX.x );
oTrack.field<TracksTag::StateCovX>( 1 ).set( covX.y );
oTrack.field<TracksTag::StateCovX>( 2 ).set( covX.z );
for ( int idx = 0; idx < velo_ancestor.nHits().hmax( finalMask ); ++idx ) {
oTrack.field<TracksTag::vp_indices>( idx ).set( velo_ancestor.vp_index( idx ) );
oTrack.field<TracksTag::lhcbIDs>( idx ).setLHCbID( velo_ancestor.lhcbID( idx ) );
}
if ( m_filterMode ) {
outputTracks.store<TracksTag::nUTHits>( currentsize, simd::int_v{0} );
oTrack.field<TracksTag::nUTHits>().set( 0 );
continue;
}
......@@ -1225,7 +1197,7 @@ namespace LHCb::Pr {
trackIndex2++;
}
}
outputTracks.store<TracksTag::nUTHits>( currentsize, simd::int_v{nUTHits}, finalMask );
oTrack.field<TracksTag::nUTHits>().set( simd::int_v{nUTHits} );
}
}
} // namespace LHCb::Pr
Tr/PatPV/src/TrackBeamLineVertexFinderSoA.cpp
View file @ c2f95a6d
......@@ -430,8 +430,8 @@ LHCb::Event::v2::RecVertices TrackBeamLineVertexFinderSoA::operator()( const Eve
// beamline. cache the covariance matrix at this position. I'd
// rather us a combination of copy_if and transform, but don't know
// how to do that efficiently.
PVTracks pvtracks;
PVTracksExtension trks_ext;
PVTracks pvtracks{Zipping::generateZipIdentifier(), memResource};
PVTracksExtension trks_ext{Zipping::generateZipIdentifier(), memResource};
pvtracks.reserve( tracksForward.size() + tracksBackward.size() );
trks_ext.reserve( tracksForward.size() + tracksBackward.size() );
{
......
Tr/TrackUtils/tests/src/TestZipInfrastructure.cpp
View file @ c2f95a6d
......@@ -145,7 +145,7 @@ BOOST_AUTO_TEST_CASE( new_struct_from_zip ) {
auto pt = chunk.pt();
auto ipchi2 = chunk.bestPV().ipchi2();
auto index = chunk.bestPV().index();
passing_cut += popcount( ( pt > 400.f ) && ( ipchi2 > 1.f ) );
passing_cut += popcount( chunk.loop_mask() && ( pt > 400.f ) && ( ipchi2 > 1.f ) );
if ( print ) { std::cout << "pt " << pt << " ipchi2 " << ipchi2 << " index " << index << std::endl; }
}
......