|
|
@@ -43,6 +43,18 @@ bool in_det(const MatchedTrack &mt, int &&det, int &&layer){
|
|
|
return hit.det == det && hit.lay == layer;
|
|
|
};
|
|
|
|
|
|
+float pseudorapidity(float z, float r){
|
|
|
+ float theta = atan2(r, z);
|
|
|
+ return -log(tan(theta/2.0));
|
|
|
+}
|
|
|
+float pseudorapidity(float x, float y, float z){
|
|
|
+ float r = sqrt(x*x + y*y);
|
|
|
+ return pseudorapidity(z, r);
|
|
|
+}
|
|
|
+template<typename T>
|
|
|
+float pseudorapidity(const T &t){
|
|
|
+ return pseudorapidity(t.x, t.y, t.z);
|
|
|
+}
|
|
|
|
|
|
|
|
|
vector<string> seedTypes =
|
|
|
@@ -71,68 +83,202 @@ void register_objects(TrackingDataSet& tds){
|
|
|
}
|
|
|
|
|
|
void setup_first_hit_pairs(TrackingDataSet& tds){
|
|
|
- // Finds pairs of (rechit, simhit) where the rechit is the innermost hit on
|
|
|
- // a seed in a particular barrel layer.
|
|
|
typedef std::tuple<PixRecHit, SimHit> HitPair;
|
|
|
- auto& matched_hits_in_layer =
|
|
|
+
|
|
|
+ auto& find_matched_nth_hit_in_layer =
|
|
|
func<vector<HitPair>(vector<Seed>,
|
|
|
vector<PixRecHit>,
|
|
|
- vector<SimHit>, int)>("find_matched_innermost_hits_in_layer",
|
|
|
+ vector<SimHit>,
|
|
|
+ int, int, int)>("find_matched_nth_hit_in_layer",
|
|
|
FUNC(([](const vector<Seed>& seeds,
|
|
|
const vector<PixRecHit>& pixrec_hits,
|
|
|
const vector<SimHit>& sim_hits,
|
|
|
- const int&& bpix_layer){
|
|
|
+ const int&& det,
|
|
|
+ const int&& bpix_layer,
|
|
|
+ const int&& hit_number){
|
|
|
vector<HitPair> matched_hits;
|
|
|
- for(const Seed &seed : seeds){
|
|
|
- if( seed.algoOriginal < 0 || seed.algoOriginal >= seedTypes.size()) continue;
|
|
|
- for(auto tup : boost::combine(seed.hitIdx, seed.hitType)){ //for hits in track's seed
|
|
|
- int hitIdx, hitType;
|
|
|
- boost::tie(hitIdx, hitType) = tup;
|
|
|
- if(hitType != HIT_TYPE_PIXEL) continue; // take only pixel hits for now
|
|
|
- const PixRecHit &rec_hit = pixrec_hits[hitIdx];
|
|
|
- if(rec_hit.det == PIXEL_BARREL && rec_hit.lay == bpix_layer){
|
|
|
- if(rec_hit.simHitIdx.size() > 0){
|
|
|
- matched_hits.push_back({rec_hit, sim_hits[rec_hit.simHitIdx[0]]});
|
|
|
- }
|
|
|
+ for(const Seed &seed : seeds){ // loop over all seeds
|
|
|
+ if(seed.hitIdx.size() <= hit_number) continue;
|
|
|
+ if(seed.algoOriginal < 0 || seed.algoOriginal >= seedTypes.size()) continue;
|
|
|
+ if(seed.hitType[hit_number] != HIT_TYPE_PIXEL) continue; // take only pixel hits for now
|
|
|
+ const PixRecHit &rec_hit = pixrec_hits[seed.hitIdx[hit_number]];
|
|
|
+ if(rec_hit.det == det && rec_hit.lay == bpix_layer){
|
|
|
+ if(rec_hit.simHitIdx.size() > 0){
|
|
|
+ // take first matched simhit (should be the closest one)
|
|
|
+ matched_hits.push_back({rec_hit, sim_hits[rec_hit.simHitIdx[0]]});
|
|
|
}
|
|
|
- break;
|
|
|
}
|
|
|
}
|
|
|
return matched_hits;
|
|
|
})));
|
|
|
|
|
|
- auto first_hits_in_B1 = fv::apply(matched_hits_in_layer, fv::tuple(seeds, pixrec_hits, sim_hits, constant("1", 1)), "first_hits_in_B1");
|
|
|
- auto first_hits_in_B2 = fv::apply(matched_hits_in_layer, fv::tuple(seeds, pixrec_hits, sim_hits, constant("2", 2)), "first_hits_in_B2");
|
|
|
-
|
|
|
- auto& calc_dphi = func<float(HitPair)>("calc_dphi",
|
|
|
- FUNC(([](const HitPair& hit_pair){
|
|
|
- const auto &rec_hit = std::get<PixRecHit>(hit_pair);
|
|
|
- const auto &sim_hit = std::get<SimHit>(hit_pair);
|
|
|
- return atan2(rec_hit.x, rec_hit.y) - atan2(sim_hit.x, sim_hit.y);
|
|
|
+ auto& select_even_odd_ladder_blade_hit_pairs =
|
|
|
+ func<vector<HitPair>(vector<HitPair>, bool)>("select_even_odd_ladder_blade_hit_pairs",
|
|
|
+ FUNC(([](const vector<HitPair>& hit_pairs,
|
|
|
+ const bool &&odd){
|
|
|
+ vector<HitPair> even_pairs;
|
|
|
+ for(const HitPair &hit_pair : hit_pairs){ // loop over all seeds
|
|
|
+ if(std::get<PixRecHit>(hit_pair).ladder_blade % 2 == odd){
|
|
|
+ even_pairs.push_back(hit_pair);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return even_pairs;
|
|
|
})));
|
|
|
|
|
|
- TH1Params params = {"$\\Delta \\phi$(rad)", 50, -0.001, 0.001, ""};
|
|
|
- tds.register_container<ContainerTH1Many<float>>("dphi_matched_hits_from_B1",
|
|
|
- fv::map(calc_dphi, first_hits_in_B1),
|
|
|
- "Matched Hits $\\Delta \\phi$ - B1", params);
|
|
|
- tds.register_container<ContainerTH1Many<float>>("dphi_matched_hits_from_B2",
|
|
|
- fv::map(calc_dphi, first_hits_in_B2),
|
|
|
- "Matched Hits $\\Delta \\phi$ - B2", params);
|
|
|
-
|
|
|
- auto& calc_dz = func<float(HitPair)>("calc_dz",
|
|
|
- FUNC(([](const HitPair& hit_pair){
|
|
|
- const auto &rec_hit = std::get<PixRecHit>(hit_pair);
|
|
|
- const auto &sim_hit = std::get<SimHit>(hit_pair);
|
|
|
- return rec_hit.z - sim_hit.z;
|
|
|
+ auto barrel_val = constant("PIXEL_BARREL", PIXEL_BARREL);
|
|
|
+ auto endcap_val = constant("PIXEL_ENDCAP", PIXEL_ENDCAP);
|
|
|
+ auto first_hit = constant("1st", 0);
|
|
|
+ auto second_hit = constant("2nd", 1);
|
|
|
+
|
|
|
+ // First hits on inner three bpix layers
|
|
|
+ auto first_hits_in_B1 = fv::apply(find_matched_nth_hit_in_layer,
|
|
|
+ fv::tuple(seeds, pixrec_hits, sim_hits, barrel_val, constant("L1", 1), first_hit), "first_hits_in_B1");
|
|
|
+ auto first_hits_in_B2 = fv::apply(find_matched_nth_hit_in_layer,
|
|
|
+ fv::tuple(seeds, pixrec_hits, sim_hits, barrel_val, constant("L2", 2), first_hit), "first_hits_in_B2");
|
|
|
+ auto first_hits_in_B3 = fv::apply(find_matched_nth_hit_in_layer,
|
|
|
+ fv::tuple(seeds, pixrec_hits, sim_hits, barrel_val, constant("L3", 3), first_hit), "first_hits_in_B3");
|
|
|
+
|
|
|
+ // Second hits on outer three bpix layers
|
|
|
+ auto second_hits_in_B2 = fv::apply(find_matched_nth_hit_in_layer,
|
|
|
+ fv::tuple(seeds, pixrec_hits, sim_hits, barrel_val, constant("L2", 2), second_hit), "second_hits_in_B2");
|
|
|
+ auto second_hits_in_B3 = fv::apply(find_matched_nth_hit_in_layer,
|
|
|
+ fv::tuple(seeds, pixrec_hits, sim_hits, barrel_val, constant("L3", 3), second_hit), "second_hits_in_B3");
|
|
|
+ auto second_hits_in_B4 = fv::apply(find_matched_nth_hit_in_layer,
|
|
|
+ fv::tuple(seeds, pixrec_hits, sim_hits, barrel_val, constant("L4", 4), second_hit), "second_hits_in_B4");
|
|
|
+
|
|
|
+ /* auto first_hits_in_F1 = fv::apply(find_matched_nth_hit_in_layer, */
|
|
|
+ /* fv::tuple(seeds, pixrec_hits, sim_hits, endcap_val, constant("1", 1)), "first_hits_in_F1"); */
|
|
|
+ /* auto first_hits_in_F2 = fv::apply(find_matched_nth_hit_in_layer, */
|
|
|
+ /* fv::tuple(seeds, pixrec_hits, sim_hits, endcap_val, constant("2", 2)), "first_hits_in_F2"); */
|
|
|
+
|
|
|
+ // Even vs Odd Ladders
|
|
|
+ auto even = constant("even", false);
|
|
|
+ auto odd = constant("odd", true);
|
|
|
+
|
|
|
+ auto first_hits_in_B1_even_ladder = fv::apply(select_even_odd_ladder_blade_hit_pairs,
|
|
|
+ fv::tuple(first_hits_in_B1, even), "first_hits_in_B1_even_ladder");
|
|
|
+ auto first_hits_in_B1_odd_ladder = fv::apply(select_even_odd_ladder_blade_hit_pairs,
|
|
|
+ fv::tuple(first_hits_in_B1, odd), "first_hits_in_B1_odd_ladder");
|
|
|
+
|
|
|
+ auto first_hits_in_B2_even_ladder = fv::apply(select_even_odd_ladder_blade_hit_pairs,
|
|
|
+ fv::tuple(first_hits_in_B2, even), "first_hits_in_B2_even_ladder");
|
|
|
+ auto first_hits_in_B2_odd_ladder = fv::apply(select_even_odd_ladder_blade_hit_pairs,
|
|
|
+ fv::tuple(first_hits_in_B2, odd), "first_hits_in_B2_odd_ladder");
|
|
|
+
|
|
|
+ auto first_hits_in_B3_even_ladder = fv::apply(select_even_odd_ladder_blade_hit_pairs,
|
|
|
+ fv::tuple(first_hits_in_B3, even), "first_hits_in_B3_even_ladder");
|
|
|
+ auto first_hits_in_B3_odd_ladder = fv::apply(select_even_odd_ladder_blade_hit_pairs,
|
|
|
+ fv::tuple(first_hits_in_B3, odd), "first_hits_in_B3_odd_ladder");
|
|
|
+
|
|
|
+ //Plots for dPhi of collections defined above
|
|
|
+ auto& calc_dphi_v_eta = func<pair_vec(vector<HitPair>)>("calc_dphi_v_eta",
|
|
|
+ FUNC(([](const vector<HitPair>& hit_pairs){
|
|
|
+ vector<float> dphis;
|
|
|
+ vector<float> etas;
|
|
|
+ for(auto hit_pair : hit_pairs){
|
|
|
+ auto& pixrec_hit = std::get<PixRecHit>(hit_pair);
|
|
|
+ auto& sim_hit = std::get<SimHit>(hit_pair);
|
|
|
+ dphis.push_back(atan2(sim_hit.x, sim_hit.y) - atan2(pixrec_hit.x, pixrec_hit.y));
|
|
|
+ etas.push_back(pseudorapidity(pixrec_hit));
|
|
|
+ }
|
|
|
+ return std::make_pair(etas, dphis);
|
|
|
+ })));
|
|
|
+ TH2Params params_dphi = {"$\\eta$", 100, -4, 4,
|
|
|
+ "$\\Delta \\phi$(rad)", 75, -.0015, .0015};
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B1",
|
|
|
+ fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B1)),
|
|
|
+ "First Hit in BPIX-L1", params_dphi);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B2",
|
|
|
+ fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B2)),
|
|
|
+ "First Hit in BPIX-L2", params_dphi);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B3",
|
|
|
+ fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B3)),
|
|
|
+ "First Hit in BPIX-L3", params_dphi);
|
|
|
+
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B1_even_ladder",
|
|
|
+ fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B1_even_ladder)),
|
|
|
+ "First Hit in BPIX-L1 - Even Ladders", params_dphi);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B1_odd_ladder",
|
|
|
+ fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B1_odd_ladder)),
|
|
|
+ "First Hit in BPIX-L1 - Odd Ladders", params_dphi);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B2_even_ladder",
|
|
|
+ fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B2_even_ladder)),
|
|
|
+ "First Hit in BPIX-L2 - Even Ladders", params_dphi);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B2_odd_ladder",
|
|
|
+ fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B2_odd_ladder)),
|
|
|
+ "First Hit in BPIX-L2 - Odd Ladders", params_dphi);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B3_even_ladder",
|
|
|
+ fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B3_even_ladder)),
|
|
|
+ "First Hit in BPIX-L3 - Even Ladders", params_dphi);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B3_odd_ladder",
|
|
|
+ fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B3_odd_ladder)),
|
|
|
+ "First Hit in BPIX-L3 - Odd Ladders", params_dphi);
|
|
|
+
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_second_hits_in_B2",
|
|
|
+ fv::apply(calc_dphi_v_eta, fv::tuple(second_hits_in_B2)),
|
|
|
+ "Second Hit in BPIX-L2", params_dphi);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_second_hits_in_B3",
|
|
|
+ fv::apply(calc_dphi_v_eta, fv::tuple(second_hits_in_B3)),
|
|
|
+ "Second Hit in BPIX-L3", params_dphi);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_second_hits_in_B4",
|
|
|
+ fv::apply(calc_dphi_v_eta, fv::tuple(second_hits_in_B4)),
|
|
|
+ "Second Hit in BPIX-L4", params_dphi);
|
|
|
+
|
|
|
+ //Plots for dz of collections defined above
|
|
|
+ auto& calc_dz_v_eta = func<pair_vec(vector<HitPair>)>("calc_dz_v_eta",
|
|
|
+ FUNC(([](const vector<HitPair>& hit_pairs){
|
|
|
+ vector<float> dzs;
|
|
|
+ vector<float> etas;
|
|
|
+ for(auto hit_pair : hit_pairs){
|
|
|
+ auto& pixrec_hit = std::get<PixRecHit>(hit_pair);
|
|
|
+ auto& sim_hit = std::get<SimHit>(hit_pair);
|
|
|
+ dzs.push_back(sim_hit.z - pixrec_hit.z);
|
|
|
+ etas.push_back(pseudorapidity(pixrec_hit));
|
|
|
+ }
|
|
|
+ return std::make_pair(etas, dzs);
|
|
|
})));
|
|
|
+ TH2Params params_dz = {"$\\eta$", 100, -4, 4,
|
|
|
+ "$\\Delta z$(rad)", 100, -.01, .01};
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B1",
|
|
|
+ fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B1)),
|
|
|
+ "First Hit in BPIX-L1", params_dz);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B2",
|
|
|
+ fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B2)),
|
|
|
+ "First Hit in BPIX-L2", params_dz);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B3",
|
|
|
+ fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B3)),
|
|
|
+ "First Hit in BPIX-L3", params_dz);
|
|
|
+
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B1_even_ladder",
|
|
|
+ fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B1_even_ladder)),
|
|
|
+ "First Hit in BPIX-L1 - Even Ladders", params_dz);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B1_odd_ladder",
|
|
|
+ fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B1_odd_ladder)),
|
|
|
+ "First Hit in BPIX-L1 - Odd Ladders", params_dz);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B2_even_ladder",
|
|
|
+ fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B2_even_ladder)),
|
|
|
+ "First Hit in BPIX-L2 - Even Ladders", params_dz);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B2_odd_ladder",
|
|
|
+ fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B2_odd_ladder)),
|
|
|
+ "First Hit in BPIX-L2 - Odd Ladders", params_dz);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B3_even_ladder",
|
|
|
+ fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B3_even_ladder)),
|
|
|
+ "First Hit in BPIX-L3 - Even Ladders", params_dz);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B3_odd_ladder",
|
|
|
+ fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B3_odd_ladder)),
|
|
|
+ "First Hit in BPIX-L3 - Odd Ladders", params_dz);
|
|
|
+
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dz_v_eta_second_hits_in_B2",
|
|
|
+ fv::apply(calc_dz_v_eta, fv::tuple(second_hits_in_B2)),
|
|
|
+ "Second Hit in BPIX-L2", params_dz);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dz_v_eta_second_hits_in_B3",
|
|
|
+ fv::apply(calc_dz_v_eta, fv::tuple(second_hits_in_B3)),
|
|
|
+ "Second Hit in BPIX-L3", params_dz);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("dz_v_eta_second_hits_in_B4",
|
|
|
+ fv::apply(calc_dz_v_eta, fv::tuple(second_hits_in_B4)),
|
|
|
+ "Second Hit in BPIX-L4", params_dz);
|
|
|
+
|
|
|
|
|
|
- params = {"$\\Delta z$", 50, -0.01, 0.01, ""};
|
|
|
- tds.register_container<ContainerTH1Many<float>>("dz_matched_hits_from_B1",
|
|
|
- fv::map(calc_dz, first_hits_in_B1),
|
|
|
- "Matched Hits $\\Delta z$ - B1", params);
|
|
|
- tds.register_container<ContainerTH1Many<float>>("dz_matched_hits_from_B2",
|
|
|
- fv::map(calc_dz, first_hits_in_B2),
|
|
|
- "Matched Hits $\\Delta z$ - B2", params);
|
|
|
}
|
|
|
|
|
|
void setup_matched_tracks(TrackingDataSet& tds){
|
|
|
@@ -191,7 +337,6 @@ void setup_matched_tracks(TrackingDataSet& tds){
|
|
|
|
|
|
void setup_residuals(TrackingDataSet &tds){
|
|
|
|
|
|
-
|
|
|
auto matched_tracks = lookup<vector<MatchedTrack>>("matched_tracks");
|
|
|
|
|
|
// Break matched_tracks into catagories based on Barrel/Endcap and layer
|
|
|
@@ -369,6 +514,37 @@ void setup_residuals(TrackingDataSet &tds){
|
|
|
|
|
|
}
|
|
|
|
|
|
+void setup_ladder_vs_phi(TrackingDataSet& tds){
|
|
|
+ auto& calc_phi_vs_ladder =
|
|
|
+ func<pair_vec(vector<PixRecHit>, int)>("calc_phi_vs_ladder",
|
|
|
+ FUNC(([](const vector<PixRecHit>& pixrec_hits, int layer){
|
|
|
+ std::vector<float> phis;
|
|
|
+ std::vector<float> ladders;
|
|
|
+ for(const PixRecHit &pixrec_hit : pixrec_hits){
|
|
|
+ if(pixrec_hit.det == PIXEL_BARREL && pixrec_hit.lay == layer){
|
|
|
+ float phi = pixrec_hit.phi();
|
|
|
+ unsigned short ladder = pixrec_hit.ladder_blade;
|
|
|
+ phis.push_back(phi);
|
|
|
+ ladders.push_back(ladder);
|
|
|
+ INFO(boost::format("Hit Phi: %7.3f , Hit detID: %8x, Ladder: %d")
|
|
|
+ % phi % pixrec_hit.detId % ladder);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return std::make_pair(phis, ladders);
|
|
|
+ })));
|
|
|
+
|
|
|
+ TH2Params params = {"$\\phi$", 100, -3.14159, 3.14159,
|
|
|
+ "Ladder Number", 50, 0, 50};
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("rechit_phi_vs_ladder_l1",
|
|
|
+ fv::apply(calc_phi_vs_ladder, fv::tuple(pixrec_hits, constant<int>("1",1))),
|
|
|
+ "phi vs ladder number - Layer 1", params);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("rechit_phi_vs_ladder_l2",
|
|
|
+ fv::apply(calc_phi_vs_ladder, fv::tuple(pixrec_hits, constant<int>("2",2))),
|
|
|
+ "phi vs ladder number - Layer 2", params);
|
|
|
+ tds.register_container<ContainerTH2Many<float>>("rechit_phi_vs_ladder_l3",
|
|
|
+ fv::apply(calc_phi_vs_ladder, fv::tuple(pixrec_hits, constant<int>("3",3))),
|
|
|
+ "phi vs ladder number - Layer 3", params);
|
|
|
+}
|
|
|
|
|
|
void run_analysis(const vector<fv::util::DataFileDescriptor>& dfds, const string output_filename, bool silent){
|
|
|
gSystem->Load("libfilval.so");
|
|
|
@@ -377,16 +553,18 @@ void run_analysis(const vector<fv::util::DataFileDescriptor>& dfds, const string
|
|
|
};
|
|
|
|
|
|
string log_filename = replace_suffix(output_filename, ".log");
|
|
|
- fv::util::Log::init_logger(log_filename, fv::util::LogPriority::kLogDebug);
|
|
|
+ fv::util::Log::init_logger(log_filename, fv::util::LogPriority::kLogInfo);
|
|
|
|
|
|
TrackingDataSet tds(output_filename, dfds, "trackingNtuple/tree");
|
|
|
/* tds.set_max_events(10); */
|
|
|
register_objects(tds);
|
|
|
|
|
|
- setup_matched_tracks(tds);
|
|
|
- setup_residuals(tds);
|
|
|
+ /* setup_matched_tracks(tds); */
|
|
|
+ /* setup_residuals(tds); */
|
|
|
setup_first_hit_pairs(tds);
|
|
|
|
|
|
+ /* setup_ladder_vs_phi(tds); */
|
|
|
+
|
|
|
tds.process(silent);
|
|
|
tds.save_all();
|
|
|
}
|
Caleb Fangmeier