L1AlgoTBB.h

Go to the documentation of this file.

#ifndef L1AlgoTBB_h
#define L1AlgoTBB_h
 
#include "L1Algo.h"
 
#ifdef TBB
 
#include "tbb/blocked_range.h"
#include "tbb/parallel_for.h"
#include "tbb/task_scheduler_init.h"
using namespace tbb;
 
class ParalleledDup
{
    // input
    int isec;
    L1Station* vStations;
    int NStations;
    int* StsHitsStartIndex;
    int* StsHitsStopIndex;
    vector<unsigned char>& vSFlag;
    vector<unsigned char>& vSFlagB;
    std::vector<L1HitPoint>& vStsHits;
    double Pick_r;
    double Pick_m;
    double MaxInvMom;
    fvec targX;
    fvec targY;
    fvec targZ;
    L1FieldValue& targB;
    L1XYMeasurementInfo& TargetXYInfo;
 
    int* n_g1;
    unsigned* portionStopIndex;
    L1TrackPar* T_g1;
    L1FieldRegion* fld_g1;
    THitI* hitsl_g1;
    //  fvec *x_minusV_g1; fvec *x_plusV_g1; fvec *y_minusV_g1; fvec *y_plusV_g1;
    // output
    THitI* Duplets_start;
    THitI* Duplets_hits;
 
    int* n_g2;
    THitI* i1_g2;
    //  L1TrackPar *T_g2;
    //  L1FieldRegion *fld_g2;
    //  fvec *u_front_g2; fvec *u_back_g2;
    //  THitI *hitsl_g2;
    THitI* hitsm_g2;
    //  fvec *x_minusV_g2; fvec *x_plusV_g2; fvec *y_minusV_g2; fvec *y_plusV_g2;
 
  public:
    void operator()(const blocked_range<size_t>& r) const;
 
    ParalleledDup(
        // input
        int isec_,
        L1Station* vStations_,
        int NStations_,
        int* StsHitsStartIndex_,
        int* StsHitsStopIndex_,
        vector<unsigned char>& vSFlag_,
        vector<unsigned char>& vSFlagB_,
        std::vector<L1HitPoint>& vStsHits_,
        double Pick_r_,
        double Pick_m_,
        double MaxInvMom_,
        fvec targX_,
        fvec targY_,
        fvec targZ_,
        L1FieldValue& targB_,
        L1XYMeasurementInfo& TargetXYInfo_,
 
        int* n_g1_,
        unsigned* portionStopIndex_,
        L1TrackPar* T_g1_,
        L1FieldRegion* fld_g1_,
        THitI* hitsl_g1_,
        //                              fvec *x_minusV_g1_, fvec *x_plusV_g1_, fvec *y_minusV_g1_, fvec *y_plusV_g1_,
        // output
        THitI* Duplets_start_,
        THitI* Duplets_hits_,
 
        int* n_g2_,
        THitI* i1_g2_,
        //                              L1TrackPar *T_g2_,
        //                              L1FieldRegion *fld_g2_,
        //                              fvec *u_front_g2_, fvec *u_back_g2_,
        //                              THitI *hitsl_g2_,
        THitI* hitsm_g2_
        //                              fvec *x_minusV_g2_, fvec *x_plusV_g2_, fvec *y_minusV_g2_, fvec *y_plusV_g2_
        )
        : isec(isec_)
        , vStations(vStations_)
        , NStations(NStations_)
        , StsHitsStartIndex(StsHitsStartIndex_)
        , StsHitsStopIndex(StsHitsStopIndex_)
        , vSFlag(vSFlag_)
        , vSFlagB(vSFlagB_)
        , vStsHits(vStsHits_)
        , Pick_r(Pick_r_)
        , Pick_m(Pick_m_)
        , MaxInvMom(MaxInvMom_)
        , targX(targX_)
        , targY(targY_)
        , targZ(targZ_)
        , targB(targB_)
        , TargetXYInfo(TargetXYInfo_)
        ,
 
        n_g1(n_g1_)
        , portionStopIndex(portionStopIndex_)
        , T_g1(T_g1_)
        , fld_g1(fld_g1_)
        , hitsl_g1(hitsl_g1_)
        ,
        //                                          x_minusV_g1(x_minusV_g1_), x_plusV_g1(x_plusV_g1_),
        // y_minusV_g1(y_minusV_g1_), y_plusV_g1(y_plusV_g1_), output
        Duplets_start(Duplets_start_)
        , Duplets_hits(Duplets_hits_)
        ,
 
        n_g2(n_g2_)
        , i1_g2(i1_g2_)
        ,
        //                                          T_g2(T_g2_),
        //                                          fld_g2(fld_g2_),
        //                                          u_front_g2(u_front_g2_), u_back_g2(u_back_g2_),
        //                                          hitsl_g2(hitsl_g2_),
        hitsm_g2(hitsm_g2_)
    //                                          x_minusV_g2(x_minusV_g2_), x_plusV_g2(x_plusV_g2_),
    // y_minusV_g2(y_minusV_g2_), y_plusV_g2(y_plusV_g2_)
    {};
 
    ~ParalleledDup() {};
};
 
void ParalleledDup::operator()(const blocked_range<size_t>& r) const
{
 
    for (int istal = r.begin(); istal < (int)r.end(); ++istal) {
        //      cout<< " ParalleledDup::operator(). Station: " << istal << endl;
        DupletsStaPort(   // input
            isec, istal, vStsHits, targX, targY, targZ, targB, TargetXYInfo,
 
            n_g1, portionStopIndex, T_g1, fld_g1, hitsl_g1,
            //                                          x_minusV_g1, x_plusV_g1, y_minusV_g1, y_plusV_g1,
            // output
            Duplets_start, Duplets_hits,
 
            n_g2, i1_g2,
            //                                          T_g2,
            //                                          fld_g2,
            //                                          u_front_g2, u_back_g2,
            //                                          hitsl_g2,
            hitsm_g2
            //                                          x_minusV_g2, x_plusV_g2, y_minusV_g2, y_plusV_g2
        );
    }
}
 
class ParalleledTrip
{
    // input
    int isec;
    L1Station* vStations;
    int NStations;
    int* StsHitsStartIndex;
    int* StsHitsStopIndex;
    std::vector<L1HitPoint>& svStsHits;
    double Pick_r;
    double TRACK_CHI2_CUT;
    double MaxInvMom;
 
    int* n_g1;
    L1TrackPar* T_g1;
    L1FieldRegion* fld_g1;
    THitI* hitsl_g1;
 
    int* n_g2;
    unsigned* portionStopIndex;
    THitI* i1_g2;
    /*  L1FieldRegion *fld_g2;
        fvec *u_front_g2; fvec *u_back_g2;
        L1TrackPar *T_g2;*/
    //  THitI *hitsl_g2;
    THitI* hitsm_g2;
    //  fvec *x_minusV_g2; fvec *x_plusV_g2; fvec *y_minusV_g2; fvec *y_plusV_g2;
    // output
    THitI* Duplets_start;
    THitI* Duplets_hits;
    std::vector<L1Triplet>* vTriplets_part;
    unsigned* TripStartIndexH;
    unsigned* TripStopIndexH;
 
  public:
    void operator()(const blocked_range<size_t>& r) const;
 
    ParalleledTrip(
        // input
        int isec_,
        L1Station* vStations_,
        int NStations_,
        int* StsHitsStartIndex_,
        int* StsHitsStopIndex_,
        std::vector<L1HitPoint>& vStsHits_,
        double Pick_r_,
        double TRACK_CHI2_CUT_,
        double MaxInvMom_,
 
        int* n_g1_,
        L1TrackPar* T_g1_,
        L1FieldRegion* fld_g1_,
        THitI* hitsl_g1_,
 
        int* n_g2_,
        unsigned* portionStopIndex_,
        THitI* i1_g2_,
        /*L1FieldRegion *fld_g2_,
        fvec *u_front_g2_, fvec *u_back_g2_,
        L1TrackPar *T_g2_,*/
        //                              THitI *hitsl_g2_,
        THitI* hitsm_g2_,
        //                              fvec *x_minusV_g2_, fvec *x_plusV_g2_, fvec *y_minusV_g2_, fvec *y_plusV_g2_,
        // output
        THitI* Duplets_start_,
        THitI* Duplets_hits_,
        std::vector<L1Triplet>* vTriplets_part_,
        unsigned* TripStartIndexH_,
        unsigned* TripStopIndexH_)
        :   // input
        isec(isec_)
        , vStations(vStations_)
        , NStations(NStations_)
        , StsHitsStartIndex(StsHitsStartIndex_)
        , StsHitsStopIndex(StsHitsStopIndex_)
        , svStsHits(vStsHits_)
        , Pick_r(Pick_r_)
        , TRACK_CHI2_CUT(TRACK_CHI2_CUT_)
        , MaxInvMom(MaxInvMom_)
        ,
 
        n_g1(n_g1_)
        , T_g1(T_g1_)
        , fld_g1(fld_g1_)
        , hitsl_g1(hitsl_g1_)
        ,
 
        n_g2(n_g2_)
        , portionStopIndex(portionStopIndex_)
        , i1_g2(i1_g2_)
        ,
        /*                                          fld_g2(fld_g2_),
                                                    u_front_g2(u_front_g2_), u_back_g2(u_back_g2_),
                                                    T_g2(T_g2_),*/
        //                                          hitsl_g2(hitsl_g2_),
        hitsm_g2(hitsm_g2_)
        ,
        //                                          x_minusV_g2(x_minusV_g2_), x_plusV_g2(x_plusV_g2_),
        // y_minusV_g2(y_minusV_g2_), y_plusV_g2(y_plusV_g2_), output
        Duplets_start(Duplets_start_)
        , Duplets_hits(Duplets_hits_)
        , vTriplets_part(vTriplets_part_)
        , TripStartIndexH(TripStartIndexH_)
        , TripStopIndexH(TripStopIndexH_) {};
 
    ~ParalleledTrip() {};
};
 
void ParalleledTrip::operator()(const blocked_range<size_t>& r) const
{
 
    for (int istal = r.begin(); istal < (int)r.end(); ++istal) {
        //      cout<< " ParalleledTrip::operator(). Station: " << istal << endl;
        TripletsStaPort(   // input
            isec, istal, svStsHits, n_g1, T_g1, fld_g1, hitsl_g1,
 
            n_g2, portionStopIndex, i1_g2,
            /*                                          fld_g2,
                                                        u_front_g2, u_back_g2,
                                                        T_g2,*/
            //                                          hitsl_g2,
            hitsm_g2,
            //                                          x_minusV_g2, x_plusV_g2, y_minusV_g2, y_plusV_g2,
            // output
            Duplets_start, Duplets_hits, vTriplets_part, TripStartIndexH, TripStopIndexH);
    }
}
#endif   // TBB
 
#endif