From 1cebf4df537820cba9c521f83f55571c55353c2d Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 10:36:04 -0800 Subject: [PATCH 01/70] Add files via upload --- processors/src/RoryClusterAnaProcessor.cxx | 677 +++++++++++++++++ .../src/RoryClusterCompareAnaProcessor.cxx | 717 ++++++++++++++++++ processors/src/SvtRawDataAnaProcessor.cxx | 192 ++++- 3 files changed, 1568 insertions(+), 18 deletions(-) create mode 100644 processors/src/RoryClusterAnaProcessor.cxx create mode 100644 processors/src/RoryClusterCompareAnaProcessor.cxx diff --git a/processors/src/RoryClusterAnaProcessor.cxx b/processors/src/RoryClusterAnaProcessor.cxx new file mode 100644 index 000000000..7f067e1c6 --- /dev/null +++ b/processors/src/RoryClusterAnaProcessor.cxx @@ -0,0 +1,677 @@ +/** + * @file RoryClusterAnaProcessor.cxx + * @brief AnaProcessor used fill histograms to study svt hit fitting + * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory + */ +#include "RoryClusterAnaProcessor.h" +//#include "Int_t.h" +#include + +RoryClusterAnaProcessor::RoryClusterAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ + mmapper_ = new ModuleMapper(2021); +} +//TODO CHECK THIS DESTRUCTOR +RoryClusterAnaProcessor::~RoryClusterAnaProcessor(){} + +void RoryClusterAnaProcessor::configure(const ParameterSet& parameters) { + std::cout << "Configuring RoryClusterAnaProcessor" << std::endl; + try + { + debug_ = parameters.getInteger("debug"); + layer_ = parameters.getInteger("layer"); + module_ = parameters.getInteger("module"); + isMC_ = parameters.getInteger("isMC"); + doingTracks_ = (parameters.getInteger("doTrack")==1); + pcut_ = (float)parameters.getDouble("cut"); + //anaName_ = parameters.getString("anaName"); + } + catch (std::runtime_error& error) + { + std::cout << error.what() << std::endl; + } + +} + + +void RoryClusterAnaProcessor::initialize(TTree* tree) { + fillDeads(); + tree_= tree; + //tree_->Print(); + + if(isMC_==1){ + layers_=new TH1F("layers","MC Strip Width for All Clusters",12,0.0,12.0); + layersOnTrk_=new TH1F("layersOnTrk","MC Strip Width for Clusters on Track",12,0.0,12.0); + layersOffTrk_=new TH1F("layersOffTrk","MC Strip Width for Clusters off Track",12,0.0,12.0); + charges_=new TH1F("charges","MC Charge Distribution for All Clusters",1000,0.0,0.000016); + chargesOnTrk_=new TH1F("chargesOnTrk","MC Charge Distribution for On Track",1000,0.0,.000016); + chargesOffTrk_=new TH1F("chargesOffTrk","MC Charge Distribution for Off Track",1000,0.0,0.000016); + + layersNTD_=new TH1F("layersNTD","MC Strip Width for All Clusters",12,0.0,12.0); + layersOnTrkNTD_=new TH1F("layersOnTrkNTD","MC Strip Width for Clusters on Track",12,0.0,12.0); + layersOffTrkNTD_=new TH1F("layersOffTrkNTD","MC Strip Width for Clusters off Track",12,0.0,12.0); + chargesNTD_=new TH1F("chargesNTD","MC Charge Distribution for All Clusters",1000,0.0,0.000016); + chargesOnTrkNTD_=new TH1F("chargesOnTrkNTD","MC Charge Distribution for On Track",1000,0.0,.000016); + chargesOffTrkNTD_=new TH1F("chargesOffTrkNTD","MC Charge Distribution for Off Track",1000,0.0,0.000016); + + positions_=new TH1F("Positions","MC Location of Cluster Hit;Layer;Hits",14,0.0,14.0); + positionsOnTrk_=new TH1F("PositionsOnTrk","MC Location of Cluster Hit for On Track",14,0.0,14.0); + ClusDistances_=new TH1F("Minimum Cluster Difference","MC Minimum Distance Between Clusters",14,0.0,14.0); + ClusDistancesNTD_=new TH1F("Minimum Cluster Difference","MC Minimum Distance Between Clusters",14,0.0,14.0); + + times_=new TH1F("Times","MC Time of Cluster Hit",1000,-60.0,60.0); + timesOnTrk_=new TH1F("TimesOnTrk","MC Time of On Track Cluster Hit",1000,-60.0,60.0); + timesOffTrk_=new TH1F("TimesOffTrk","MC Time of Off Cluster Hit",1000,-60.0,60.0); + timesNTD_=new TH1F("TimesNTD","MC Time of Cluster Hit NTD",1000,-60.0,60.0); + timesOnTrkNTD_=new TH1F("TimesOnTrkNTD","MC Time of On Track Cluster Hit NTD",1000,-60.0,60.0); + timesOffTrkNTD_=new TH1F("TimesOffTrkNTD","MC Time of Off Cluster Hit NTD",1000,-60.0,60.0); + + std::cout<<"I GET HERE 1"<SetBranchAddress("SiClusters",&Clusters_,&bClusters_); + tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); + tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); + std::cout<<"I GET HERE 2"<SetBranchAddress("SiClusters",&Clusters_,&bClusters_); + tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); + tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); + if(doingTracks_){ + tree_->SetBranchAddress("KalmanFullTracks",&tracks_,&btracks_); + } + std::cout<<"I GET HERE 2"<size()<<" hits"<size();i++){ + Track* track = tracks_->at(i); + //bool general = ((layer_==-1)||(module_==-1)); + //if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + if(track->getTrackTime()*track->getTrackTime()<100.0){ + Z0VNShare2Hist_->Fill(track->getZ0Err(),track->getNShared()); + if(track->getP()Fill(track->getZ0Err(),track->getNShared()); + } + } + //} + } + } + for(int i = 0; i < Clusters_->size(); i++){ + TrackerHit * clu = Clusters_->at(i); + Int_t LAYER = -1; + Int_t MODULE = -1; + + RawSvtHit * seed = (RawSvtHit*)(clu->getRawHits().At(0)); + + LAYER=clu->getLayer(); + MODULE=seed->getModule(); + + if(doingTracks_){ + bool isShared = false;int increment = 0; + for(int i = 0;isize();i++){ + Track* track = tracks_->at(i); + for(int j = 0; jgetSvtHits().GetEntries();j++){ + TrackerHit * test = (TrackerHit *)(track->getSvtHits().At(j)); + if(clu->getTime()==test->getTime()){ + increment+=1; + } + } + } + if(increment>1){ + isShared=true; + } + if(increment>0){ + bool general = ((layer_==-1)||(module_==-1)); + if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + if(isShared){ + SharedAmplitudes_->Fill(clu->getCharge()); + SharedTimes_->Fill(clu->getTime()); + }else{ + UnSharedAmplitudes_->Fill(clu->getCharge()); + UnSharedTimes_->Fill(clu->getTime()); + } + } + } + } + + + float seedStrip = (float)(seed->getStrip()); + float nLayers = (float)(clu->getRawHits().GetEntries()); + float ncharges = (float)(clu->getCharge()); + float ntimes = (float)(clu->getTime()); + //float ntimes = 0.0; + //for(int p = 0;pgetRawHits().GetEntries();p++){ + // RawSvtHit * holder = (RawSvtHit*)(clu->getRawHits().At(p)); + // ntimes+=holder->getT0(0); + //} + //ntimes=gtimes;//%ncharges; + bool onTrk = false; + bool NTD = false; + for(unsigned int j = 0; j < ClustersKF_->size(); j++){ + if(clu->getID()==(ClustersKF_->at(j)->getID())){ + onTrk = true; + } + } + //std::cout<getVolume()<getHwFromSw(input); + //std::cout<=0){ + NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelL)]==1); + } + if(((feb<=1)&&(channelR<=511))||((feb>1)&&(channelR<=639))){ + NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelR)]==1); + } + bool general = ((layer_==-1)||(module_==-1)); + if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + //NOW IS THE PART WHERE I FILL THE CLUSTER DISTANCE HISTOGRAM + float Dist=69420; + for(int p = 0; p < Clusters_->size(); p++){ + if(p==i){continue;} + TrackerHit * clu2 = Clusters_->at(p); + RawSvtHit * seed2 = (RawSvtHit*)(clu2->getRawHits().At(0)); + float LAYER2=clu->getLayer(); + float MODULE2=seed->getModule(); + if((not(LAYER2==LAYER))or(not(MODULE2==MODULE))){continue;} + float dist = ((float)(seed2->getStrip()))-seedStrip; + if(dist<0){dist*=-1.0;} + if(distFill(Dist); + if(NTD){ClusDistancesNTD_->Fill(Dist);} + } + //std::cout<<"HELLO"<Fill(nLayers); + charges_->Fill(ncharges); + positions_->Fill(clu->getLayer()); + times_->Fill(ntimes); + if(onTrk){ + layersOnTrk_->Fill(nLayers); + chargesOnTrk_->Fill(ncharges); + timesOnTrk_->Fill(ntimes); + }else{ + layersOffTrk_->Fill(nLayers); + chargesOffTrk_->Fill(ncharges); + timesOffTrk_->Fill(ntimes); + } + if(NTD){ + layersNTD_->Fill(nLayers); + chargesNTD_->Fill(ncharges); + positionsOnTrk_->Fill(clu->getLayer()); + timesNTD_->Fill(ntimes); + if(onTrk){ + layersOnTrkNTD_->Fill(nLayers); + chargesOnTrkNTD_->Fill(ncharges); + timesOnTrkNTD_->Fill(ntimes); + }else{ + layersOffTrkNTD_->Fill(nLayers); + chargesOffTrkNTD_->Fill(ncharges); + timesOffTrkNTD_->Fill(ntimes); + } + } + } + } + return true; +} + +void RoryClusterAnaProcessor::fillDeads(){ + for(int i = 0;i<24576;i++){ + Deads_[i]=0.0; + } + std::string FILENAME="/sdf/group/hps/users/rodwyer1/run/cluster_study/badchannels2021.dat"; + std::ifstream file(FILENAME.c_str()); + std::string line; + std::getline(file,line); + while (std::getline(file, line)) { + int value = std::atoi(line.c_str()); + Deads_[value]=1.0; + } + file.close(); + return; +} + +int RoryClusterAnaProcessor::GetStrip(int feb,int hyb,int strip){ + int BigCount = 0; + if(feb<=1){ + BigCount+=feb*2048+hyb*512+strip; + }else{ + BigCount+=4096; + BigCount+=(feb-2)*2560+hyb*640+strip; + } + return BigCount; +} + +void RoryClusterAnaProcessor::Plot1(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + layers_->GetXaxis()->SetTitle("Width (strip)"); + layers_->GetYaxis()->SetTitle("Hits"); + layersOnTrk_->GetXaxis()->SetTitle("Width (strip)"); + layersOnTrk_->GetYaxis()->SetTitle("Hits"); + layersOffTrk_->GetXaxis()->SetTitle("Width (strip)"); + layersOffTrk_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Layers for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("allClusters.png"); + c1->Clear(); + + c1->SetTitle("Layers for On Track Clusters"); + layersOnTrk_->Draw("e"); + c1->SaveAs("onClusters.png"); + c1->Clear(); + + c1->SetTitle("Layers for Off Track Clusters"); + layersOffTrk_->Draw("e"); + c1->SaveAs("offClusters.png"); + c1->Clear(); + + layers_->SetTitle("Cluster Strip Width for all Cluster Cuts"); + auto legend = new TLegend(0.3,0.8,.68,.9); + layers_->SetLineColor(kCyan); + layersOnTrk_->SetLineColor(kGreen); + legend->AddEntry(layers_,"Layers"); + legend->AddEntry(layersOnTrk_,"Layers On Track"); + legend->AddEntry(layersOffTrk_,"Layers Off Track"); + layers_->Draw("e"); + layersOnTrk_->Draw("same e"); + layersOffTrk_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("PutOnTogether.png"); + c1->Clear(); + return; +} + +void RoryClusterAnaProcessor::Plot2(){ + TCanvas *c1 = new TCanvas("c"); + gPad->SetLogy(true); + c1->cd(); + + charges_->GetXaxis()->SetTitle("Charge"); + charges_->GetYaxis()->SetTitle("Hits"); + chargesOffTrk_->GetXaxis()->SetTitle("Charge"); + chargesOffTrk_->GetYaxis()->SetTitle("Hits"); + chargesOnTrk_->GetXaxis()->SetTitle("Charge"); + chargesOnTrk_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Charges for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("allClustersCharge.png"); + c1->Clear(); + + c1->SetTitle("Charges for On Track Clusters"); + chargesOnTrk_->Draw("e"); + c1->SaveAs("onClustersCharge.png"); + c1->Clear(); + + c1->SetTitle("Charges for Off Track Clusters"); + chargesOffTrk_->Draw("e"); + c1->SaveAs("offClustersCharge.png"); + c1->Clear(); + + layers_->SetTitle("Putting all Charges Together"); + auto legend = new TLegend(0.3,0.8,.68,.9); + charges_->SetLineColor(kCyan); + chargesOnTrk_->SetLineColor(kGreen); + legend->AddEntry(charges_,"Charges"); + legend->AddEntry(chargesOnTrk_,"Charges On Track"); + legend->AddEntry(chargesOffTrk_,"Charges Off Track"); + charges_->Draw("e"); + chargesOnTrk_->Draw("same e"); + chargesOffTrk_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("PutOnTogetherCharges.png"); + c1->Clear(); + return; +} + +void RoryClusterAnaProcessor::Plot3(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + layersNTD_->GetXaxis()->SetTitle("Width (strip)"); + layersNTD_->GetYaxis()->SetTitle("Hits"); + layersOnTrkNTD_->GetXaxis()->SetTitle("Width (strip)"); + layersOnTrkNTD_->GetYaxis()->SetTitle("Hits"); + layersOffTrkNTD_->GetXaxis()->SetTitle("Width (strip)"); + layersOffTrkNTD_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("NTD Layers for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("allClustersNTD.png"); + c1->Clear(); + + c1->SetTitle("NTD Layers for On Track Clusters"); + layersOnTrkNTD_->Draw("e"); + c1->SaveAs("onClustersNTD.png"); + c1->Clear(); + + c1->SetTitle("NTD Layers for Off Track Clusters"); + layersOffTrkNTD_->Draw("e"); + c1->SaveAs("offClustersNTD.png"); + c1->Clear(); + + layersNTD_->SetTitle("NTD Cluster Strip Width for all Cluster Cuts"); + auto legend = new TLegend(0.3,0.8,.68,.9); + layersNTD_->SetLineColor(kCyan); + layersOnTrkNTD_->SetLineColor(kGreen); + legend->AddEntry(layersNTD_,"Layers"); + legend->AddEntry(layersOnTrkNTD_,"Layers On Track"); + legend->AddEntry(layersOffTrkNTD_,"Layers Off Track"); + layersNTD_->Draw("e"); + layersOnTrkNTD_->Draw("same e"); + layersOffTrkNTD_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("PutOnTogetherNTD.png"); + c1->Clear(); + return; +} + +void RoryClusterAnaProcessor::Plot4(){ + TCanvas *c1 = new TCanvas("c"); + gPad->SetLogy(true); + c1->cd(); + + chargesNTD_->GetXaxis()->SetTitle("Charge"); + chargesNTD_->GetYaxis()->SetTitle("Hits"); + chargesOffTrkNTD_->GetXaxis()->SetTitle("Charge"); + chargesOffTrkNTD_->GetYaxis()->SetTitle("Hits"); + chargesOnTrkNTD_->GetXaxis()->SetTitle("Charge"); + chargesOnTrkNTD_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("NTD Charges for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("allClustersChargeNTD.png"); + c1->Clear(); + + c1->SetTitle("NTD Charges for On Track Clusters"); + chargesOnTrkNTD_->Draw("e"); + c1->SaveAs("onClustersChargeNTD.png"); + c1->Clear(); + + c1->SetTitle("NTD Charges for Off Track Clusters"); + chargesOffTrkNTD_->Draw("e"); + c1->SaveAs("offClustersChargeNTD.png"); + c1->Clear(); + + chargesNTD_->SetTitle("NTD Charge Distribution for all Charges"); + auto legend = new TLegend(0.3,0.8,.68,.9); + chargesNTD_->SetLineColor(kCyan); + chargesOnTrkNTD_->SetLineColor(kGreen); + legend->AddEntry(chargesNTD_,"Charges"); + legend->AddEntry(chargesOnTrkNTD_,"Charges On Track"); + legend->AddEntry(chargesOffTrkNTD_,"Charges Off Track"); + chargesNTD_->Draw("e"); + chargesOnTrkNTD_->Draw("same e"); + chargesOffTrkNTD_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("PutOnTogetherChargesNTD.png"); + c1->Clear(); + return; +} + +void RoryClusterAnaProcessor::Plot5(){ + TCanvas *c1 = new TCanvas("c"); + gPad->SetLogy(true); + c1->cd(); + positions_->GetXaxis()->SetTitle("Layer"); + positions_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Cluster Position for all Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("positions.png"); + c1->Clear(); + + positionsOnTrk_->GetXaxis()->SetTitle("Layer"); + positionsOnTrk_->GetYaxis()->SetTitle("Hits"); + + //c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Cluster Position for NTD Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("positionsNTD.png"); + c1->Clear(); + + ClusDistances_->GetXaxis()->SetTitle("Separation"); + ClusDistances_->GetYaxis()->SetTitle("Pairs"); + + c1->SetTitle("Cluster Separation on Same Sensors"); + ClusDistances_->Draw("e"); + c1->SaveAs("clusDistances.png"); + c1->Clear(); + + ClusDistancesNTD_->GetXaxis()->SetTitle("Separation"); + ClusDistancesNTD_->GetYaxis()->SetTitle("Pairs"); + + c1->SetTitle("Cluster Separation on Same Sensors for NTD"); + ClusDistancesNTD_->Draw("e"); + c1->SaveAs("clusDistancesNTD.png"); + c1->Clear(); +} + +void RoryClusterAnaProcessor::Plot6(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + times_->GetXaxis()->SetTitle("Times (ns)"); + times_->GetYaxis()->SetTitle("Hits"); + timesOnTrk_->GetXaxis()->SetTitle("Time (ns)"); + timesOnTrk_->GetYaxis()->SetTitle("Hits"); + timesOffTrk_->GetXaxis()->SetTitle("Time (ns)"); + timesOffTrk_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Times for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw(); + c1->SaveAs("alltimes.png"); + c1->Clear(); + + c1->SetTitle("Times for On Track Clusters"); + timesOnTrk_->Draw("e"); + c1->SaveAs("ontimes.png"); + c1->Clear(); + + c1->SetTitle("Times for Off Track Clusters"); + timesOffTrk_->Draw("e"); + c1->SaveAs("offtimes.png"); + c1->Clear(); + + times_->SetTitle("Cluster Times for all Cluster Cuts"); + auto legend = new TLegend(0.3,0.8,.68,.9); + times_->SetLineColor(kCyan); + timesOnTrk_->SetLineColor(kGreen); + legend->AddEntry(times_,"Times"); + legend->AddEntry(timesOnTrk_,"Times On Track"); + legend->AddEntry(timesOffTrk_,"Times Off Track"); + times_->Draw("e"); + timesOnTrk_->Draw("same e"); + timesOffTrk_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("PutOnTogetherTimes.png"); + c1->Clear(); + return; +} + +void RoryClusterAnaProcessor::Plot7(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + timesNTD_->GetXaxis()->SetTitle("Times (ns)"); + timesNTD_->GetYaxis()->SetTitle("Hits"); + timesOnTrkNTD_->GetXaxis()->SetTitle("Time (ns)"); + timesOnTrkNTD_->GetYaxis()->SetTitle("Hits"); + timesOffTrkNTD_->GetXaxis()->SetTitle("Time (ns)"); + timesOffTrkNTD_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Times for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("alltimesNTD.png"); + c1->Clear(); + + c1->SetTitle("Times for On Track Clusters"); + timesOnTrkNTD_->Draw("e"); + c1->SaveAs("ontimesNTD.png"); + c1->Clear(); + + c1->SetTitle("Times for Off Track Clusters"); + timesOffTrkNTD_->Draw("e"); + c1->SaveAs("offtimesNTD.png"); + c1->Clear(); + + timesNTD_->SetTitle("Cluster Times for all Cluster Cuts"); + auto legend = new TLegend(0.3,0.8,.68,.9); + timesNTD_->SetLineColor(kCyan); + timesOnTrkNTD_->SetLineColor(kGreen); + legend->AddEntry(timesNTD_,"Times"); + legend->AddEntry(timesOnTrkNTD_,"Times On Track"); + legend->AddEntry(timesOffTrkNTD_,"Times Off Track"); + timesNTD_->Draw("e"); + timesOnTrkNTD_->Draw("same e"); + timesOffTrkNTD_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("PutOnTogetherTimesNTD.png"); + c1->Clear(); + return; +} + +void RoryClusterAnaProcessor::TrackPlot1(){ + TCanvas *c1 = new TCanvas("c"); + c1->cd(); + //FIRST I DO THE PROFILES OF THE NSHARED HITS PLOTS + + TProfile* p1 = Z0VNShare2Hist_->ProfileX("p1"); + TProfile* p2 = Z0VNShare2HistCut_->ProfileX("p2"); + auto legend = new TLegend(0.3,0.8,.68,.9); + p2->SetLineColor(kRed); + p2->SetLineWidth(2.0); + p1->SetLineWidth(2.0); + legend->AddEntry(p1,"Shared Profile Not Cut"); + legend->AddEntry(p2,"Shared Profile Cut"); + p1->Draw("e"); + p2->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("Z0VSharedProfile.png"); + c1->Clear(); + + //NOW I DO THE CHARGE DISTRIBUTION FOR SHARED AND UNSHARED HITS OVERLAYED + SharedAmplitudes_->SetTitle("The Charge of Clusters Shared Between Tracks"); + legend = new TLegend(0.3,0.8,.68,.9); + SharedAmplitudes_->SetLineColor(kRed); + SharedAmplitudes_->SetLineWidth(2.0); + UnSharedAmplitudes_->SetLineWidth(2.0); + legend->AddEntry(SharedAmplitudes_,"Charge Distribution for Shared Clusters"); + legend->AddEntry(UnSharedAmplitudes_,"Charge Distribution for UnShared Clusters"); + UnSharedAmplitudes_->Draw("e"); + SharedAmplitudes_->Draw("same e"); + legend->Draw("same e"); + gPad->SetLogy(true); + c1->SaveAs("SharedVUnSharedChargeDist.png"); + c1->Clear(); + + //NOW I DO THE TIME DISTRIBUTION FOR SHARED AND UNSHARED HITS OVERLAYED + SharedTimes_->SetTitle("The Time of Clusters Shared Between Tracks"); + legend = new TLegend(0.3,0.8,.68,.9); + SharedTimes_->SetLineColor(kRed); + SharedTimes_->SetLineWidth(2.0); + UnSharedTimes_->SetLineWidth(2.0); + legend->AddEntry(SharedTimes_,"Time Distribution for Shared Clusters"); + legend->AddEntry(UnSharedTimes_,"Time Distribution for UnShared Clusters"); + UnSharedTimes_->Draw("e"); + SharedTimes_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("SharedVUnSharedTimeDist.png"); + gPad->SetLogy(false); + c1->Clear(); + return; +} + +/*void RoryClusterAnaProcessor::ClusterFit(){ + return; +}*/ + +void RoryClusterAnaProcessor::finalize() { + Plot1(); + Plot2(); + Plot3(); + Plot4(); + Plot5(); + Plot6(); + Plot7(); + if(doingTracks_){ + TrackPlot1(); + } + //ClusterFit(); + return; +} +DECLARE_PROCESSOR(RoryClusterAnaProcessor); diff --git a/processors/src/RoryClusterCompareAnaProcessor.cxx b/processors/src/RoryClusterCompareAnaProcessor.cxx new file mode 100644 index 000000000..fbce55d2c --- /dev/null +++ b/processors/src/RoryClusterCompareAnaProcessor.cxx @@ -0,0 +1,717 @@ +/** + * @file RoryClusterCompareAnaProcessor.cxx + * @brief AnaProcessor used to compare two means of reconstruction directly. + * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory + */ +#include "RoryClusterCompareAnaProcessor.h" +//#include "Int_t.h" +#include + +RoryClusterCompareAnaProcessor::RoryClusterCompareAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ + mmapper_ = new ModuleMapper(2021); +} +//TODO CHECK THIS DESTRUCTOR +RoryClusterCompareAnaProcessor::~RoryClusterCompareAnaProcessor(){} + +void RoryClusterCompareAnaProcessor::configure(const ParameterSet& parameters) { + std::cout << "Configuring RoryClusterCompareAnaProcessor" << std::endl; + try + { + debug_ = parameters.getInteger("debug"); + layer_ = parameters.getInteger("layer"); + module_ = parameters.getInteger("module"); + isMC_ = parameters.getInteger("isMC"); + doingTracks_ = (parameters.getInteger("doTrack")==1); + pcut_ = (float)parameters.getDouble("cut"); + //anaName_ = parameters.getString("anaName"); + } + catch (std::runtime_error& error) + { + std::cout << error.what() << std::endl; + } + +} + + +void RoryClusterCompareAnaProcessor::initialize(TTree* tree) { + fillDeads(); + tree_= tree; + //tree_->Print(); + + if(isMC_==1){ + layers1_=new TH1F("layers","MC Strip Width for All Clusters",12,0.0,12.0); + layersOnTrk1_=new TH1F("layersOnTrk","MC Strip Width for Clusters on Track",12,0.0,12.0); + layersOffTrk1_=new TH1F("layersOffTrk","MC Strip Width for Clusters off Track",12,0.0,12.0); + charges1_=new TH1F("charges","MC Charge Distribution for All Clusters",1000,0.0,0.000016); + chargesOnTrk1_=new TH1F("chargesOnTrk","MC Charge Distribution for On Track",1000,0.0,.000016); + chargesOffTrk1_=new TH1F("chargesOffTrk","MC Charge Distribution for Off Track",1000,0.0,0.000016); + + layersNTD1_=new TH1F("layersNTD","MC Strip Width for All Clusters",12,0.0,12.0); + layersOnTrkNTD1_=new TH1F("layersOnTrkNTD","MC Strip Width for Clusters on Track",12,0.0,12.0); + layersOffTrkNTD1_=new TH1F("layersOffTrkNTD","MC Strip Width for Clusters off Track",12,0.0,12.0); + chargesNTD1_=new TH1F("chargesNTD","MC Charge Distribution for All Clusters",1000,0.0,0.000016); + chargesOnTrkNTD1_=new TH1F("chargesOnTrkNTD","MC Charge Distribution for On Track",1000,0.0,.000016); + chargesOffTrkNTD1_=new TH1F("chargesOffTrkNTD","MC Charge Distribution for Off Track",1000,0.0,0.000016); + + positions1_=new TH1F("Positions","MC Location of Cluster Hit;Layer;Hits",14,0.0,14.0); + positionsOnTrk1_=new TH1F("PositionsOnTrk","MC Location of Cluster Hit for On Track",14,0.0,14.0); + ClusDistances1_=new TH1F("Minimum Cluster Difference","MC Minimum Distance Between Clusters",14,0.0,14.0); + ClusDistancesNTD1_=new TH1F("Minimum Cluster Difference","MC Minimum Distance Between Clusters",14,0.0,14.0); + + times1_=new TH1F("Times","MC Time of Cluster Hit",1000,-60.0,60.0); + timesOnTrk1_=new TH1F("TimesOnTrk","MC Time of On Track Cluster Hit",1000,-60.0,60.0); + timesOffTrk1_=new TH1F("TimesOffTrk","MC Time of Off Cluster Hit",1000,-60.0,60.0); + timesNTD1_=new TH1F("TimesNTD","MC Time of Cluster Hit NTD",1000,-60.0,60.0); + timesOnTrkNTD1_=new TH1F("TimesOnTrkNTD","MC Time of On Track Cluster Hit NTD",1000,-60.0,60.0); + timesOffTrkNTD1_=new TH1F("TimesOffTrkNTD","MC Time of Off Cluster Hit NTD",1000,-60.0,60.0); + + std::cout<<"I GET HERE 1"<SetBranchAddress("SiClusters",&Clusters_,&bClusters_); + tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); + tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); + std::cout<<"I GET HERE 2"<SetBranchAddress("SiClusters",&Clusters_,&bClusters_); + tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); + tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); + tree_->SetBranchAddress("Identifier",&ident_,&bident_); + if(doingTracks_){ + tree_->SetBranchAddress("KalmanFullTracks",&tracks_,&btracks_); + } + std::cout<<"I GET HERE 2"<size()<<" hits"<1.0){std::cout<size();i++){ + Track* track = tracks_->at(i); + //bool general = ((layer_==-1)||(module_==-1)); + //if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + if(track->getTrackTime()*track->getTrackTime()<100.0){ + if(ident_<1.5){Z0VNShare2Hist1_->Fill(track->getZ0Err(),track->getNShared());}else{Z0VNShare2Hist2_->Fill(track->getZ0Err(),track->getNShared());} + if(track->getP()Fill(track->getZ0Err(),track->getNShared());}else{Z0VNShare2HistCut2_->Fill(track->getZ0Err(),track->getNShared());} + } + } + //} + + //Track Momentum for In and Out of time hits (All not just transverse) + if(ident_<1.5){TrackMomentumAllTime1_->Fill(track->getP());}else{TrackMomentumAllTime2_->Fill(track->getP());} + + if(track->getTrackTime()*track->getTrackTime()<16.0){ + if(ident_<1.5){TrackMomentumInTime1_->Fill(track->getP());}else{TrackMomentumInTime2_->Fill(track->getP());} + }else{ + if(ident_<1.5){TrackMomentumOutTime1_->Fill(track->getP());}else{TrackMomentumOutTime2_->Fill(track->getP());} + } + + //Transverse Track Momentum for same cuts + if(ident_<1.5){TrackMomentumTAllTime1_->Fill(track->getP());}else{TrackMomentumTAllTime2_->Fill(track->getP());} + + if(track->getTrackTime()*track->getTrackTime()<16.0){ + if(ident_<1.5){TrackMomentumTInTime1_->Fill(track->getP());}else{TrackMomentumTInTime2_->Fill(track->getP());} + }else{ + if(ident_<1.5){TrackMomentumTOutTime1_->Fill(track->getP());}else{TrackMomentumTOutTime2_->Fill(track->getPt());} + } + } + } + for(int i = 0; i < Clusters_->size(); i++){ + TrackerHit * clu = Clusters_->at(i); + Int_t LAYER = -1; + Int_t MODULE = -1; + + RawSvtHit * seed = (RawSvtHit*)(clu->getRawHits().At(0)); + + LAYER=clu->getLayer(); + MODULE=seed->getModule(); + + if(doingTracks_){ + bool isShared = false;int increment = 0; + for(int i = 0;isize();i++){ + Track* track = tracks_->at(i); + for(int j = 0; jgetSvtHits().GetEntries();j++){ + TrackerHit * test = (TrackerHit *)(track->getSvtHits().At(j)); + if(clu->getTime()==test->getTime()){ + increment+=1; + } + } + } + if(increment>1){ + isShared=true; + } + if(increment>0){ + bool general = ((layer_==-1)||(module_==-1)); + if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + if(isShared){ + if(ident_<1.5){SharedAmplitudes1_->Fill(clu->getCharge());}else{SharedAmplitudes2_->Fill(clu->getCharge());} + if(ident_<1.5){SharedTimes1_->Fill(clu->getTime());}else{SharedTimes2_->Fill(clu->getTime());} + }else{ + if(ident_<1.5){UnSharedAmplitudes1_->Fill(clu->getCharge());}else{UnSharedAmplitudes2_->Fill(clu->getCharge());} + if(ident_<1.5){UnSharedTimes1_->Fill(clu->getTime());}else{UnSharedTimes2_->Fill(clu->getTime());} + } + } + } + } + + + float seedStrip = (float)(seed->getStrip()); + float nLayers = (float)(clu->getRawHits().GetEntries()); + float ncharges = (float)(clu->getCharge()); + float ntimes = (float)(clu->getTime()); + //float ntimes = 0.0; + //for(int p = 0;pgetRawHits().GetEntries();p++){ + // RawSvtHit * holder = (RawSvtHit*)(clu->getRawHits().At(p)); + // ntimes+=holder->getT0(0); + //} + //ntimes=gtimes;//%ncharges; + bool onTrk = false; + bool NTD = false; + for(unsigned int j = 0; j < ClustersKF_->size(); j++){ + if(clu->getID()==(ClustersKF_->at(j)->getID())){ + onTrk = true; + } + } + //std::cout<getVolume()<getHwFromSw(input); + //std::cout<=0){ + NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelL)]==1); + } + if(((feb<=1)&&(channelR<=511))||((feb>1)&&(channelR<=639))){ + NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelR)]==1); + } + bool general = ((layer_==-1)||(module_==-1)); + if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + //NOW IS THE PART WHERE I FILL THE CLUSTER DISTANCE HISTOGRAM + float Dist=69420; + for(int p = 0; p < Clusters_->size(); p++){ + if(p==i){continue;} + TrackerHit * clu2 = Clusters_->at(p); + RawSvtHit * seed2 = (RawSvtHit*)(clu2->getRawHits().At(0)); + float LAYER2=clu->getLayer(); + float MODULE2=seed->getModule(); + if((not(LAYER2==LAYER))or(not(MODULE2==MODULE))){continue;} + float dist = ((float)(seed2->getStrip()))-seedStrip; + if(dist<0){dist*=-1.0;} + if(distFill(Dist);}else{/*std::cout<<"1 "<Fill(Dist);} + if(NTD){if(ident_<1.5){ClusDistancesNTD1_->Fill(Dist);}else{ClusDistancesNTD2_->Fill(Dist);}} + } + //std::cout<<"HELLO"<Fill(nLayers);}else{layers2_->Fill(nLayers);} + if(ident_<1.5){charges1_->Fill(ncharges);}else{charges2_->Fill(ncharges);} + if(ident_<1.5){positions1_->Fill(clu->getLayer());}else{/*std::cout<<"2"<Fill(clu->getLayer());} + if(ident_<1.5){times1_->Fill(ntimes);}else{times2_->Fill(ntimes);} + if(onTrk){ + if(ident_<1.5){layersOnTrk1_->Fill(nLayers);}else{layersOnTrk2_->Fill(nLayers);} + if(ident_<1.5){chargesOnTrk1_->Fill(ncharges);}else{chargesOnTrk2_->Fill(ncharges);} + if(ident_<1.5){timesOnTrk1_->Fill(ntimes);}else{timesOnTrk2_->Fill(ntimes);} + if(ident_<1.5){positionsOnTrk1_->Fill(clu->getLayer());}else{positionsOnTrk2_->Fill(clu->getLayer());}//std::cout<<"3"<Fill(nLayers);}else{layersOffTrk2_->Fill(nLayers);} + if(ident_<1.5){chargesOffTrk1_->Fill(ncharges);}else{chargesOffTrk2_->Fill(ncharges);} + if(ident_<1.5){timesOffTrk1_->Fill(ntimes);}else{timesOffTrk2_->Fill(ntimes);} + } + if(NTD){ + if(ident_<1.5){layersNTD1_->Fill(nLayers);}else{layersNTD2_->Fill(nLayers);} + if(ident_<1.5){chargesNTD1_->Fill(ncharges);}else{chargesNTD2_->Fill(ncharges);} + if(ident_<1.5){timesNTD1_->Fill(ntimes);}else{timesNTD2_->Fill(ntimes);} + if(onTrk){ + if(ident_<1.5){layersOnTrkNTD1_->Fill(nLayers);}else{layersOnTrkNTD2_->Fill(nLayers);} + if(ident_<1.5){chargesOnTrkNTD1_->Fill(ncharges);}else{chargesOnTrkNTD2_->Fill(ncharges);} + if(ident_<1.5){timesOnTrkNTD1_->Fill(ntimes);}else{timesOnTrkNTD2_->Fill(ntimes);} + }else{ + if(ident_<1.5){layersOffTrkNTD1_->Fill(nLayers);}else{layersOffTrkNTD2_->Fill(nLayers);} + if(ident_<1.5){chargesOffTrkNTD1_->Fill(ncharges);}else{chargesOffTrkNTD2_->Fill(ncharges);} + if(ident_<1.5){timesOffTrkNTD1_->Fill(ntimes);}else{timesOffTrkNTD2_->Fill(ntimes);} + } + } + } + } + return true; +} + +void RoryClusterCompareAnaProcessor::fillDeads(){ + for(int i = 0;i<24576;i++){ + Deads_[i]=0.0; + } + std::string FILENAME="/sdf/group/hps/users/rodwyer1/run/cluster_study/badchannels2021.dat"; + std::ifstream file(FILENAME.c_str()); + std::string line; + std::getline(file,line); + while (std::getline(file, line)) { + int value = std::atoi(line.c_str()); + Deads_[value]=1.0; + } + file.close(); + return; +} + +int RoryClusterCompareAnaProcessor::GetStrip(int feb,int hyb,int strip){ + int BigCount = 0; + if(feb<=1){ + BigCount+=feb*2048+hyb*512+strip; + }else{ + BigCount+=4096; + BigCount+=(feb-2)*2560+hyb*640+strip; + } + return BigCount; +} + +void RoryClusterCompareAnaProcessor::Plot1(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + layers1_->GetXaxis()->SetTitle("Width (strip)"); + layers1_->GetYaxis()->SetTitle("Hits"); + layersOnTrk1_->GetXaxis()->SetTitle("Width (strip)"); + layersOnTrk1_->GetYaxis()->SetTitle("Hits"); + layersOffTrk1_->GetXaxis()->SetTitle("Width (strip)"); + layersOffTrk1_->GetYaxis()->SetTitle("Hits"); + layers1_->SetLineColor(kRed); + layersOnTrk1_->SetLineColor(kRed); + layersOffTrk1_->SetLineColor(kRed); + + + layers2_->GetXaxis()->SetTitle("Width (strip)"); + layers2_->GetYaxis()->SetTitle("Hits"); + layersOnTrk2_->GetXaxis()->SetTitle("Width (strip)"); + layersOnTrk2_->GetYaxis()->SetTitle("Hits"); + layersOffTrk2_->GetXaxis()->SetTitle("Width (strip)"); + layersOffTrk2_->GetYaxis()->SetTitle("Hits"); + layers2_->SetLineColor(kBlue); + layersOnTrk2_->SetLineColor(kBlue); + layersOffTrk2_->SetLineColor(kBlue); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Layers for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + layers2_->Draw("e same"); + auto legend1 = new TLegend(0.3,0.8,.68,.9); + legend1->AddEntry(layers1_,"Layers Rec 1"); + legend1->AddEntry(layers2_,"Layers Rec 2"); + legend1->Draw("same e"); + c1->SaveAs("allClusters.png"); + c1->Clear(); + + c1->SetTitle("Layers for On Track Clusters"); + layersOnTrk1_->Draw("e"); + layersOnTrk2_->Draw("e same"); + auto legend2 = new TLegend(0.3,0.8,.68,.9); + legend2->AddEntry(layersOnTrk1_,"Layers On Track Rec 1"); + legend2->AddEntry(layersOnTrk2_,"Layers On Track Rec 2"); + legend2->Draw("same e"); + c1->SaveAs("onClusters.png"); + c1->Clear(); + + c1->SetTitle("Layers for Off Track Clusters"); + layersOffTrk1_->Draw("e"); + layersOffTrk2_->Draw("e same"); + auto legend3 = new TLegend(0.3,0.8,.68,.9); + legend3->AddEntry(layersOffTrk1_,"Layers Off Track Rec 1"); + legend3->AddEntry(layersOffTrk2_,"Layers Off Track Rec 2"); + legend3->Draw("same e"); + c1->SaveAs("offClusters.png"); + c1->Clear(); + return; +} + +void RoryClusterCompareAnaProcessor::Plot2(){ + TCanvas *c1 = new TCanvas("c"); + //gPad->SetLogy(true); + c1->cd(); + + charges1_->GetXaxis()->SetTitle("Charge"); + charges1_->GetYaxis()->SetTitle("Hits"); + chargesOffTrk1_->GetXaxis()->SetTitle("Charge"); + chargesOffTrk1_->GetYaxis()->SetTitle("Hits"); + chargesOnTrk1_->GetXaxis()->SetTitle("Charge"); + chargesOnTrk1_->GetYaxis()->SetTitle("Hits"); + charges1_->SetLineColor(kRed); + chargesOnTrk1_->SetLineColor(kRed); + chargesOffTrk1_->SetLineColor(kRed); + + charges2_->GetXaxis()->SetTitle("Charge"); + charges2_->GetYaxis()->SetTitle("Hits"); + chargesOffTrk2_->GetXaxis()->SetTitle("Charge"); + chargesOffTrk2_->GetYaxis()->SetTitle("Hits"); + chargesOnTrk2_->GetXaxis()->SetTitle("Charge"); + chargesOnTrk2_->GetYaxis()->SetTitle("Hits"); + charges2_->SetLineColor(kBlue); + chargesOnTrk2_->SetLineColor(kBlue); + chargesOffTrk2_->SetLineColor(kBlue); + + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Charges for All Clusters"); + charges1_->Draw("e"); + charges2_->Draw("e same"); + auto legend1 = new TLegend(0.3,0.8,.68,.9); + legend1->AddEntry(charges1_,"Charges Rec 1"); + legend1->AddEntry(charges2_,"Charges Rec 2"); + legend1->Draw("same e"); + c1->SaveAs("allClustersCharge.png"); + c1->Clear(); + + c1->SetTitle("Charges for On Track Clusters"); + chargesOnTrk1_->Draw("e"); + chargesOnTrk2_->Draw("e same"); + auto legend2 = new TLegend(0.3,0.8,.68,.9); + legend2->AddEntry(chargesOnTrk1_,"Charges On Track Rec 1"); + legend2->AddEntry(chargesOnTrk2_,"Charges On Track Rec 2"); + legend2->Draw("same e"); + c1->SaveAs("onClustersCharge.png"); + c1->Clear(); + + c1->SetTitle("Charges for Off Track Clusters"); + chargesOffTrk1_->Draw("e"); + chargesOffTrk2_->Draw("e same"); + auto legend3 = new TLegend(0.3,0.8,.68,.9); + legend3->AddEntry(chargesOffTrk1_,"Charges Off Track Rec 1"); + legend3->AddEntry(chargesOffTrk2_,"Charges Off Track Rec 2"); + legend3->Draw("same e"); + c1->SaveAs("offClustersCharge.png"); + c1->Clear(); + return; +} + +void RoryClusterCompareAnaProcessor::Plot3(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + + times1_->GetXaxis()->SetTitle("Charge"); + times1_->GetYaxis()->SetTitle("Hits"); + timesOffTrk1_->GetXaxis()->SetTitle("Charge"); + timesOffTrk1_->GetYaxis()->SetTitle("Hits"); + timesOnTrk1_->GetXaxis()->SetTitle("Charge"); + timesOnTrk1_->GetYaxis()->SetTitle("Hits"); + times1_->SetLineColor(kRed); + timesOnTrk1_->SetLineColor(kRed); + timesOffTrk1_->SetLineColor(kRed); + + + times2_->GetXaxis()->SetTitle("Charge"); + times2_->GetYaxis()->SetTitle("Hits"); + timesOffTrk2_->GetXaxis()->SetTitle("Charge"); + timesOffTrk2_->GetYaxis()->SetTitle("Hits"); + timesOnTrk2_->GetXaxis()->SetTitle("Charge"); + timesOnTrk2_->GetYaxis()->SetTitle("Hits"); + times2_->SetLineColor(kBlue); + timesOnTrk2_->SetLineColor(kBlue); + timesOffTrk2_->SetLineColor(kBlue); + + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Times for All Clusters"); + times1_->Draw("e"); + times2_->Draw("e same"); + auto legend1 = new TLegend(0.3,0.8,.68,.9); + legend1->AddEntry(times1_,"Times Rec 1"); + legend1->AddEntry(times2_,"Times Rec 2"); + legend1->Draw("same e"); + c1->SaveAs("alltimes.png"); + c1->Clear(); + + c1->SetTitle("Times for On Track Clusters"); + timesOnTrk1_->Draw("e"); + timesOnTrk2_->Draw("e same"); + auto legend2 = new TLegend(0.3,0.8,.68,.9); + legend2->AddEntry(timesOnTrk1_,"Times On Track Rec 1"); + legend2->AddEntry(timesOnTrk2_,"Times On Track Rec 2"); + legend2->Draw("same e"); + c1->SaveAs("ontimes.png"); + c1->Clear(); + + c1->SetTitle("Times for Off Track Clusters"); + timesOffTrk1_->Draw("e"); + timesOffTrk2_->Draw("e same"); + auto legend3 = new TLegend(0.3,0.8,.68,.9); + legend3->AddEntry(timesOffTrk1_,"Times Off Track Rec 1"); + legend3->AddEntry(timesOffTrk2_,"Times Off Track Rec 2"); + legend3->Draw("same e"); + c1->SaveAs("offtimes.png"); + c1->Clear(); + return; +} + +void RoryClusterCompareAnaProcessor::Plot4(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + + positions1_->GetXaxis()->SetTitle("Position"); + positions1_->GetYaxis()->SetTitle("Hits"); + positionsOnTrk1_->GetXaxis()->SetTitle("Position"); + positionsOnTrk1_->GetYaxis()->SetTitle("Hits"); + + positions2_->GetXaxis()->SetTitle("Position"); + positions2_->GetYaxis()->SetTitle("Hits"); + positionsOnTrk2_->GetXaxis()->SetTitle("Position"); + positionsOnTrk2_->GetYaxis()->SetTitle("Hits"); + + positions1_->SetLineColor(kRed); + positionsOnTrk1_->SetLineColor(kRed); + positions2_->SetLineColor(kBlue); + positionsOnTrk2_->SetLineColor(kBlue); + + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Position for All Clusters"); + positions1_->Draw("e"); + positions2_->Draw("e same"); + auto legend1 = new TLegend(0.3,0.8,.68,.9); + legend1->AddEntry(positions1_,"Position Rec 1"); + legend1->AddEntry(positions2_,"Position Rec 2"); + legend1->Draw("same e"); + c1->SaveAs("positions.png"); + c1->Clear(); + + c1->SetTitle("Position for On Track Clusters"); + positionsOnTrk1_->Draw("e"); + positionsOnTrk2_->Draw("e same"); + auto legend2 = new TLegend(0.3,0.8,.68,.9); + legend2->AddEntry(positionsOnTrk1_,"Position On Track Rec 1"); + legend2->AddEntry(positionsOnTrk2_,"Position On Track Rec 2"); + legend2->Draw("same e"); + c1->SaveAs("onpositions.png"); + c1->Clear(); + + c1->SetTitle("Cluster Distances"); + positionsOnTrk1_->Draw("e"); + positionsOnTrk2_->Draw("e same"); + auto legend3 = new TLegend(0.3,0.8,.68,.9); + legend3->AddEntry(positionsOnTrk1_,"Cluster Distances Rec 1"); + legend3->AddEntry(positionsOnTrk2_,"Cluster Distances Rec 2"); + legend3->Draw("same e"); + c1->SaveAs("clusDistances.png"); + c1->Clear(); + + return; +} + +void RoryClusterCompareAnaProcessor::TrackPlot1(){ + TCanvas *c1 = new TCanvas("c"); + c1->cd(); + gPad->SetLogy(false); + TrackMomentumAllTime1_->GetXaxis()->SetTitle("Track Number"); + TrackMomentumAllTime1_->GetYaxis()->SetTitle("Momentum"); + TrackMomentumInTime1_->GetXaxis()->SetTitle("Track Number"); + TrackMomentumInTime1_->GetYaxis()->SetTitle("Momentum"); + TrackMomentumOutTime1_->GetXaxis()->SetTitle("Track Number"); + TrackMomentumOutTime1_->GetYaxis()->SetTitle("Momentum"); + + TrackMomentumAllTime1_->SetLineColor(kRed); + TrackMomentumInTime1_->SetLineColor(kRed); + TrackMomentumOutTime1_->SetLineColor(kRed); + TrackMomentumAllTime2_->SetLineColor(kBlue); + TrackMomentumInTime2_->SetLineColor(kBlue); + TrackMomentumOutTime2_->SetLineColor(kBlue); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Momentum for All Tracks"); + TrackMomentumAllTime1_->Draw("e"); + TrackMomentumAllTime2_->Draw("e same"); + auto legend1 = new TLegend(0.3,0.8,.68,.9); + legend1->AddEntry(TrackMomentumAllTime1_,"Momenta Rec 1"); + legend1->AddEntry(TrackMomentumAllTime2_,"Momenta Rec 2"); + legend1->Draw("same e"); + c1->SaveAs("allTracksMomenta.png"); + c1->Clear(); + + c1->SetTitle("Momentum for In Time Tracks"); + TrackMomentumInTime1_->Draw("e"); + TrackMomentumInTime2_->Draw("e same"); + auto legend2 = new TLegend(0.3,0.8,.68,.9); + legend2->AddEntry(TrackMomentumInTime1_,"Momenta Rec 1"); + legend2->AddEntry(TrackMomentumInTime2_,"Momenta Rec 2"); + legend2->Draw("same e"); + c1->SaveAs("inTimeTracksMomenta.png"); + c1->Clear(); + + gPad->SetLogy(true); + c1->SetTitle("Momentum for Out Time Tracks"); + TrackMomentumOutTime1_->Draw("e"); + TrackMomentumOutTime2_->Draw("e same"); + auto legend3 = new TLegend(0.3,0.8,.68,.9); + legend3->AddEntry(TrackMomentumOutTime1_,"Momenta Rec 1"); + legend3->AddEntry(TrackMomentumOutTime2_,"Momenta Rec 2"); + legend3->Draw("same e"); + c1->SaveAs("outTimeTracksMomenta.png"); + c1->Clear(); + return; +} + +void RoryClusterCompareAnaProcessor::TrackPlot2(){ + TCanvas *c1 = new TCanvas("c"); + c1->cd(); + gPad->SetLogy(false); + TrackMomentumTAllTime1_->GetXaxis()->SetTitle("Track Number"); + TrackMomentumTAllTime1_->GetYaxis()->SetTitle("Momentum"); + TrackMomentumTInTime1_->GetXaxis()->SetTitle("Track Number"); + TrackMomentumTInTime1_->GetYaxis()->SetTitle("Momentum"); + TrackMomentumTOutTime1_->GetXaxis()->SetTitle("Track Number"); + TrackMomentumTOutTime1_->GetYaxis()->SetTitle("Momentum"); + + TrackMomentumTAllTime1_->SetLineColor(kRed); + TrackMomentumTInTime1_->SetLineColor(kRed); + TrackMomentumTOutTime1_->SetLineColor(kRed); + TrackMomentumTAllTime2_->SetLineColor(kBlue); + TrackMomentumTInTime2_->SetLineColor(kBlue); + TrackMomentumTOutTime2_->SetLineColor(kBlue); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Transverse Momentum for All Tracks"); + TrackMomentumTAllTime1_->Draw("e"); + TrackMomentumTAllTime2_->Draw("e same"); + auto legend1 = new TLegend(0.3,0.8,.68,.9); + legend1->AddEntry(TrackMomentumTAllTime1_,"Momenta Rec 1"); + legend1->AddEntry(TrackMomentumTAllTime2_,"Momenta Rec 2"); + legend1->Draw("same e"); + c1->SaveAs("allTracksMomentaT.png"); + c1->Clear(); + + c1->SetTitle("Transverse Momentum for In Time Tracks"); + TrackMomentumTInTime1_->Draw("e"); + TrackMomentumTInTime2_->Draw("e same"); + auto legend2 = new TLegend(0.3,0.8,.68,.9); + legend2->AddEntry(TrackMomentumTInTime1_,"Momenta Rec 1"); + legend2->AddEntry(TrackMomentumTInTime2_,"Momenta Rec 2"); + legend2->Draw("same e"); + c1->SaveAs("inTimeTracksMomentaT.png"); + c1->Clear(); + gPad->SetLogy(true); + c1->SetTitle("Transverse Momentum for Out Time Tracks"); + TrackMomentumTOutTime1_->Draw("e"); + TrackMomentumTOutTime2_->Draw("e same"); + auto legend3 = new TLegend(0.3,0.8,.68,.9); + legend3->AddEntry(TrackMomentumTOutTime1_,"Momenta Rec 1"); + legend3->AddEntry(TrackMomentumTOutTime2_,"Momenta Rec 2"); + legend3->Draw("same e"); + c1->SaveAs("outTimeTracksMomentaT.png"); + c1->Clear(); + return; +} + +void RoryClusterCompareAnaProcessor::finalize() { + Plot1(); + Plot2(); + Plot3(); + Plot4(); + if(doingTracks_){ + TrackPlot1(); + TrackPlot2(); + } + //ClusterFit(); + return; +} +DECLARE_PROCESSOR(RoryClusterCompareAnaProcessor); diff --git a/processors/src/SvtRawDataAnaProcessor.cxx b/processors/src/SvtRawDataAnaProcessor.cxx index 5d4f9b640..f2652bb95 100644 --- a/processors/src/SvtRawDataAnaProcessor.cxx +++ b/processors/src/SvtRawDataAnaProcessor.cxx @@ -1,7 +1,7 @@ /** * @file SvtRawDataAnaProcessor.cxx * @brief AnaProcessor used fill histograms to study svt hit fitting - * @author Cameron Bravo, SLAC National Accelerator Laboratory + * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory */ #include "SvtRawDataAnaProcessor.h" @@ -210,10 +210,12 @@ void SvtRawDataAnaProcessor::initialize(TTree* tree) { tree_= tree; + //tree->Show(); // init histos //histos = new RawSvtHitHistos(anaName_.c_str(), mmapper_); //histos->loadHistoConfig(histCfgFilename_); //histos->DefineHistos(); + //std::cout<<"hello4"<size()<SetBranchAddress(svtHitColl_.c_str() , &svtHits_ , &bsvtHits_ ); @@ -222,8 +224,16 @@ void SvtRawDataAnaProcessor::initialize(TTree* tree) { //tree_->SetBranchAddress("RecoEcalClusters",&recoClu_,&brecoClu_ ); //tree_->SetBranchAddress("KalmanFullTracks",&Trk_,&bTrk_); tree_->SetBranchAddress("FinalStateParticles_KF",&Part_,&bPart_); + tree_->SetBranchAddress("SiClusters",&Clusters_,&bClusters_); tree_->SetBranchAddress("EventHeader",&evH_,&bevH_); - + + /* + //Making the Hit Efficiency Tree + TTree *HitEff_ = new TTree("hitEff","hitEff"); + HitEff_->Branch("L1",&L1_,"L1/I"); + //HitEff_->SetBranchAddress("L1",&L1_,&bL1_); + */ + for (unsigned int i_reg = 0; i_reg < regionSelections_.size(); i_reg++) { std::string regname = AnaHelpers::getFileName(regionSelections_[i_reg],false); @@ -251,17 +261,22 @@ void SvtRawDataAnaProcessor::initialize(TTree* tree) { bool SvtRawDataAnaProcessor::process(IEvent* ievent) { + //std::cout<<"hello5"<getEventTime(); //I AM DOING CLUSTER MATCHING HERE :) - //std::cout<<"Here is the eventTime"<T<prescaled.Single_3_Top==1)or(tsBank_->prescaled.Single_3_Bot==1)))){return true;} @@ -269,28 +284,133 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { //ONCE I DETERMINE A CLUSTER WHICH IS IN LINE WITH TRIG, I CAN USE ANY CLUSTERS CLOSE IN TIME. //std::cout<<"Trigger Time: "<singletrigs.at(0).T<Fill(); + } + return true; + }*/ + for(unsigned int i = 0; isize();i++){ + Clusters_->at(i)->getLayer(); + } + for(unsigned int i = 0; i < svtHits_->size(); i++){ RawSvtHit * thisHit = svtHits_->at(i); int getNum = thisHit->getFitN();//std::cout<<"I got here 10"<size();i++){ + //std::cout<<"Do I break here 3"<at(i)->getPDG()==22){continue;} + //std::cout<<"Do I break here 4"<at(i)->getCluster().getEnergy()<0){continue;} + //std::cout<<"Do I break here 5"<at(i)->getCluster().getTime()<=40)and(Part_->at(i)->getCluster().getTime()>=36))){continue;} //std::cout<<"For each Tracker Hit I now print out Raw Hit Info: "<at(i)->getTrack().getSvtHits().GetEntries();j++){ + //std::cout<<"Do I break here 6"<at(i)->getTrack().getSvtHits().At(j)); + double TrackTime = Part_->at(i)->getTrack().getTrackTime(); //std::cout<getTime()<getRawHits().GetEntries();k++){ RawSvtHit * rHit = (RawSvtHit*)(tHit->getRawHits().At(k)); - if(rHit->getT0(0)==thisHit->getT0(0)){Continue=false;} + //if(rHit->getT0(0)==thisHit->getT0(0)){ + //STR=rHit->getStrip(); + int mode=0; + if((rHit->getT0(0)==thisHit->getT0(0))and(mode==0)){//or(mode==2))){ + //This is the HIT ON TRACK Modes + bool InCluster = false; + int LAY = 0;//THE PURPOSE OF LAY IS TO COUNT THE NUMBER OF HITS PER LAYER + //std::cout<<"DID I GET HERE B4 CLUSTERS"<size(); Cl++){ + //std::cout<<"DO I GET HERE"<at(Cl)->getRawHits().GetEntries(); Clh++){ + //std::cout<<"DO I GET HERE 2"<at(Cl)->getRawHits().At(Clh)); + if((cluHit->getLayer()==thisHit->getLayer())and(cluHit->getModule()==thisHit->getModule())){ + LAY++; + } + if((cluHit->getT0(0)==thisHit->getT0(0))){//and(not(Clusters_->at(Cl)->getID()==tHit->getID()))){ + InCluster = true; + HITC=Clusters_->at(Cl)->getRawHits().GetEntries(); + HITL=LAY; + if(Clusters_->at(Cl)->getRawHits().GetEntries()==2){ + RawSvtHit * otherHit = (RawSvtHit*)(Clusters_->at(Cl)->getRawHits().At((Clh+1)%2)); + otherTime = otherHit->getT0(0); + } + } + //if((mode==2)and((cluHit->getStrip()-thisHit->getStrip())*(cluHit->getStrip()-thisHit->getStrip())<=100)and(rHit->getLayer()==thisHit->getLayer())and(rHit->getModule()==thisHit->getModule())and((cluHit->getT0(0)-TrackTime)*(cluHit->getT0(0)-TrackTime)<=(thisHit->getT0(0)-TrackTime)*(thisHit->getT0(0)-TrackTime))){ + // MissHit==true; + //} + } + } + if(InCluster){ + Continue = false; + } + }//std::cout<getLayer()<getT0(0)<=-30)and(not(rHit->getT0(0)==thisHit->getT0(0)))and(mode==1)){ + //This is the HIT OFF TRACK Mode + //You are looking at the really early time on track hits, and specifically at other hits in the same layer and module + //to see if you have evidence of a misplaced hit. + + if((rHit->getLayer()==thisHit->getLayer())and(rHit->getModule()==thisHit->getModule())){ + STR=rHit->getStrip(); + //THIS CONDITIONS ON IT BEING IN CLUSTERS + + + bool InCluster = false; + int LAY = 0;//THE PURPOSE OF LAY IS TO COUNT THE NUMBER OF HITS PER LAYER + //std::cout<<"DID I GET HERE B4 CLUSTERS"<size(); Cl++){ + //std::cout<<"DO I GET HERE"<at(Cl)->getRawHits().GetEntries(); Clh++){ + //std::cout<<"DO I GET HERE 2"<at(Cl)->getRawHits().At(Clh)); + //std::cout<getLayer()<getLayer()==thisHit->getLayer())and(cluHit->getModule()==thisHit->getModule())){ + LAY++; + } + if((cluHit->getT0(0)==thisHit->getT0(0))and(not(Clusters_->at(Cl)->getID()==tHit->getID()))){ + InCluster = true; + HITC=Clusters_->at(Cl)->getRawHits().GetEntries(); + HITL=LAY; + } + } + } + if(InCluster){ + Continue = false; + } + } + } + + + //if(rHit->getT0(0)==thisHit->getT0(0)){ + //Continue=false; + //bool helper=true;//(Part_->at(i)->getTrack().getTrackerHitCount()>=12); + //helper = (helper)and(thisHit->getChiSq(0)<.9); + //helper=(helper)and(Part_->at(i)->getTrack().getChi2()<=8); + //if(helper){ + // Continue=false; + //} + //} //std::cout<<"Raw Hit T0: "<getT0(0)<at(i)->getTrack().getSvtHits().At(j)->getRawHits().At(0).getT0()<getT0(J))-(thisHit->getT0((J+1)%2)); AmpDiff=(thisHit->getT0(J))-(thisHit->getT0((J+1)%2)); if(!(reg_selectors_[regions_[i_reg]]->passCutLt("TimeDiff_lt",TimeDiff*TimeDiff,weight))){continue;} - } + } + //std::cout<<"Did I atleast make it here?"<passCutEq("getId_lt",J,weight))){continue;} if(!(reg_selectors_[regions_[i_reg]]->passCutEq("getId_gt",J,weight))){continue;} if(!(reg_selectors_[regions_[i_reg]]->passCutLt("chi_lt",thisHit->getChiSq(J),weight))){continue;} @@ -320,6 +444,7 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { if(!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_ft",(((thisHit->getT0(J))-TimeRef)*((thisHit->getT0(J))-TimeRef)<((thisHit->getT0((J+1)%getNum)-TimeRef)*(thisHit->getT0((J+1)%getNum)-TimeRef)+.00001)),weight))){continue;} + //std::cout<<"I Made it here"<passCutLt("doing_ct",(((thisHit->getT0(J))-TimeRef)*((thisHit->getT0(J))-TimeRef)>((thisHit->getT0((J+1)%getNum)-TimeRef)*(thisHit->getT0((J+1)%getNum)-TimeRef)+.00001)),weight))){continue;} }else{ @@ -327,6 +452,7 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { if(!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_ct",(((thisHit->getT0(J))-TimeRef)*((thisHit->getT0(J))-TimeRef)>((thisHit->getT0((J+1)%getNum)-TimeRef)*(thisHit->getT0((J+1)%getNum)-TimeRef)+.00001)),weight))){continue;} } } + //std::cout<<"I Made it here 2"<passCutLt("doing_ca",(((thisHit->getAmp(J))-AmpRef)*((thisHit->getAmp(J))-AmpRef)<((thisHit->getAmp((J+1)%getNum)-AmpRef)*(thisHit->getAmp((J+1)%getNum)-AmpRef)+.00001)),weight))){continue;} if(!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_fterr",(((thisHit->getT0err(J))-TimeRef)*((thisHit->getT0err(J))-TimeRef)<((thisHit->getT0err((J+1)%getNum)-TimeRef)*(thisHit->getT0err((J+1)%getNum)-TimeRef)+.00001)),weight))){continue;} @@ -363,7 +489,9 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { //if(!(reg_selectors_[regions_[i_reg]]->passCutEq("time_phase",trigPhase,weight))){continue;} bool helper = false; + //std::cout<<"hello"<getEventNumber(); //std::cout<=2)){continue;} @@ -379,24 +508,45 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { sample(thisHit,regions_[i_reg],ievent,eventTime,N); } - - reg_histos_[regions_[i_reg]]->FillHistograms(thisHit,weight,J,i,TimeDiff,AmpDiff); - } + reg_histos_[regions_[i_reg]]->FillHistograms(thisHit,weight,J,i,TimeDiff,AmpDiff,STR,HITC,HITL,otherTime); + } } } //std::cout<size();i++){ + //std::cout<<"Do I break here 3"<at(i)->getPDG()==22){continue;} + //std::cout<<"Do I break here 4"<at(i)->getCluster().getEnergy()<0){continue;} + //std::cout<<"Do I break here 5"<at(i)->getCluster().getTime()<=40)and(Part_->at(i)->getCluster().getTime()>=36))){continue;} + //std::cout<<"For each Tracker Hit I now print out Raw Hit Info: "<at(i)->getTrack().getTrackerHitCount()>12){ + deno = 0; + for(int j = 0; jat(i)->getTrack().getSvtHits().GetEntries();j++){ + TrackerHit * tHit = (TrackerHit*)(Part_->at(i)->getTrack().getSvtHits().At(j)); + for(int k = 0;kgetRawHits().GetEntries();k++){ + RawSvtHit * rHit = (RawSvtHit*)(tHit->getRawHits().At(k)); + if((rHit->getLayer()==L)){ + deno = 1; + //I DID THE PROBE + } + } + } + } + } + return deno; +} +*/ + void SvtRawDataAnaProcessor::sample(RawSvtHit* thisHit,std::string word, IEvent* ievent,long T,int N){ auto mod = std::to_string(thisHit->getModule()); @@ -425,6 +575,7 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { BigCount+=(feb-2)*2560+hyb*640+(int)(thisHit->getStrip()); } //std::cout<<"READ HERE "<getStrip()<<" "<getStrip()][0]<getADCs(); //std::cout<vRange(0.0,3000.0,150.0,6000.0); readout[K]++; //auto gr = new TGraph(); @@ -592,6 +744,10 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { void SvtRawDataAnaProcessor::finalize() { outF_->cd(); + /*TDirectory* hitdir{nullptr}; + hitdir = outF_->mkdir("HitEfficiency"); + hitdir->cd(); + HitEff_->Write(); */ for(reg_it it = reg_histos_.begin(); it!=reg_histos_.end(); ++it){ std::string dirName = it->first; (it->second)->saveHistos(outF_,dirName); From 70c2ed8b797ea41b61f7f0944db9fe0c31d898a8 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 10:36:31 -0800 Subject: [PATCH 02/70] Add files via upload --- processors/include/RoryClusterAnaProcessor.h | 157 ++++++++++++++ .../include/RoryClusterCompareAnaProcessor.h | 196 ++++++++++++++++++ processors/include/SvtRawDataAnaProcessor.h | 12 +- 3 files changed, 364 insertions(+), 1 deletion(-) create mode 100644 processors/include/RoryClusterAnaProcessor.h create mode 100644 processors/include/RoryClusterCompareAnaProcessor.h diff --git a/processors/include/RoryClusterAnaProcessor.h b/processors/include/RoryClusterAnaProcessor.h new file mode 100644 index 000000000..49ce34a67 --- /dev/null +++ b/processors/include/RoryClusterAnaProcessor.h @@ -0,0 +1,157 @@ +#ifndef __RORYCLUSTER_ANAPROCESSOR_H__ +#define __RORYCLUSTER_ANAPROCESSOR_H__ + +//HPSTR +#include "HpsEvent.h" +#include "RawSvtHit.h" +#include "TrackerHit.h" +#include "RawSvtHitHistos.h" +#include "AnaHelpers.h" +#include "Event.h" +#include "BaseSelector.h" +#include "RawSvtHitHistos.h" +#include "EventHeader.h" +#include "VTPData.h" +#include "TSData.h" +#include "CalCluster.h" +#include "Track.h" +#include "TrackerHit.h" +#include "Collections.h" +//#include " +//ROOT + +#include "Processor.h" +#include "TClonesArray.h" +#include "TBranch.h" +#include "TTree.h" +#include "TFile.h" +#include "TF1.h" +#include "TGraphErrors.h" +#include "TAxis.h" +#include "TROOT.h" +#include "TPad.h" +#include "TCanvas.h" +#include "TLegend.h" +#include "TProfile.h" + +class TTree; + + +class RoryClusterAnaProcessor : public Processor { + + public: + + RoryClusterAnaProcessor(const std::string& name, Process& process); + + ~RoryClusterAnaProcessor(); + + virtual bool process(IEvent* ievent); + + virtual void initialize(TTree* tree); + + virtual void Plot1(); + + virtual void Plot2(); + + virtual void Plot3(); + + virtual void Plot4(); + + virtual void Plot5(); + + virtual void Plot6(); + + virtual void Plot7(); + + virtual void TrackPlot1(); + + //virtual void ClusterFit(); + + virtual void fillDeads(); + + virtual int GetStrip(int feb, int hyb,int strip); + + //virtual void sample(RawSvtHit* thisHit, std::string word, IEvent* ievent, long t,int i); + + //virtual int hitEff(IEvent* ievent, int L); + + //virtual TF1* fourPoleFitFunction(std::string word, int caser); + + //virtual float str_to_float(std::string word); + + //float reverseEngineerTime(float ti, long t); + + //virtual int maximum(int arr[]); + + virtual void finalize(); + + virtual void configure(const ParameterSet& parameters); + + private: + + //Containers to hold histogrammer info + //RawSvtHitHistos* histos{nullptr}; + ModuleMapper * mmapper_; + + TTree* tree_; + TBranch* bClusters_{nullptr}; + TBranch* bClustersKF_{nullptr}; + TBranch* bsvtraw_{nullptr}; + TBranch* btracks_{nullptr}; + + int layer_{-1}; + int module_{-1}; + + TH1F* layers_; + TH1F* layersOnTrk_; + TH1F* layersOffTrk_; + TH1F* charges_; + TH1F* chargesOnTrk_; + TH1F* chargesOffTrk_; + + TH1F* layersNTD_; + TH1F* layersOnTrkNTD_; + TH1F* layersOffTrkNTD_; + TH1F* chargesNTD_; + TH1F* chargesOnTrkNTD_; + TH1F* chargesOffTrkNTD_; + + TH1F* positions_; + TH1F* positionsOnTrk_; + TH1F* ClusDistances_; + TH1F* ClusDistancesNTD_; + + TH1F* times_; + TH1F* timesOnTrk_; + TH1F* timesOffTrk_; + TH1F* timesNTD_; + TH1F* timesOnTrkNTD_; + TH1F* timesOffTrkNTD_; + + //TRACKING RELATED VARIABLES + + TH2F* Z0VNShare2Hist_; + TH2F* Z0VNShare2HistCut_; + TH1F* SharedAmplitudes_; + TH1F* UnSharedAmplitudes_; + TH1F* SharedTimes_; + TH1F* UnSharedTimes_; + + float pcut_{-1.0}; + + bool doingTracks_{false}; + + float Deads_[24576]; + + std::vector * Clusters_{}; + std::vector * ClustersKF_{}; + std::vector * svtraw_{}; + std::vector * tracks_{}; + + + //std::string anaName_{"roryClusterAna"}; + int debug_{0}; + int isMC_{0}; +}; + +#endif diff --git a/processors/include/RoryClusterCompareAnaProcessor.h b/processors/include/RoryClusterCompareAnaProcessor.h new file mode 100644 index 000000000..96f1f4026 --- /dev/null +++ b/processors/include/RoryClusterCompareAnaProcessor.h @@ -0,0 +1,196 @@ +#ifndef __RORYCLUSTERCOMPARE_ANAPROCESSOR_H__ +#define __RORYCLUSTERCOMPARE_ANAPROCESSOR_H__ + +//HPSTR +#include "HpsEvent.h" +#include "RawSvtHit.h" +#include "TrackerHit.h" +#include "RawSvtHitHistos.h" +#include "AnaHelpers.h" +#include "Event.h" +#include "BaseSelector.h" +#include "RawSvtHitHistos.h" +#include "EventHeader.h" +#include "VTPData.h" +#include "TSData.h" +#include "CalCluster.h" +#include "Track.h" +#include "TrackerHit.h" +#include "Collections.h" +//#include " +//ROOT + +#include "Processor.h" +#include "TClonesArray.h" +#include "TBranch.h" +#include "TTree.h" +#include "TFile.h" +#include "TF1.h" +#include "TGraphErrors.h" +#include "TAxis.h" +#include "TROOT.h" +#include "TPad.h" +#include "TCanvas.h" +#include "TLegend.h" +#include "TProfile.h" + +class TTree; + + +class RoryClusterCompareAnaProcessor : public Processor { + + public: + + RoryClusterCompareAnaProcessor(const std::string& name, Process& process); + + ~RoryClusterCompareAnaProcessor(); + + virtual bool process(IEvent* ievent); + + virtual void initialize(TTree* tree); + + virtual void Plot1(); + + virtual void Plot2(); + + virtual void Plot3(); + + virtual void Plot4(); + + //virtual void Plot5(); + + //virtual void Plot6(); + + //virtual void Plot7(); + + virtual void TrackPlot1(); + + virtual void TrackPlot2(); + + virtual void fillDeads(); + + virtual int GetStrip(int feb, int hyb,int strip); + + virtual void finalize(); + + virtual void configure(const ParameterSet& parameters); + + private: + + //Containers to hold histogrammer info + //RawSvtHitHistos* histos{nullptr}; + ModuleMapper * mmapper_; + + TTree* tree_; + TBranch* bClusters_{nullptr}; + TBranch* bClustersKF_{nullptr}; + TBranch* bsvtraw_{nullptr}; + TBranch* btracks_{nullptr}; + TBranch* bident_{nullptr}; + + int layer_{-1}; + int module_{-1}; + + //FOR THE FIRST FILE + + TH1F* layers1_; + TH1F* layersOnTrk1_; + TH1F* layersOffTrk1_; + TH1F* charges1_; + TH1F* chargesOnTrk1_; + TH1F* chargesOffTrk1_; + + TH1F* layersNTD1_; + TH1F* layersOnTrkNTD1_; + TH1F* layersOffTrkNTD1_; + TH1F* chargesNTD1_; + TH1F* chargesOnTrkNTD1_; + TH1F* chargesOffTrkNTD1_; + + TH1F* positions1_; + TH1F* positionsOnTrk1_; + TH1F* ClusDistances1_; + TH1F* ClusDistancesNTD1_; + + TH1F* times1_; + TH1F* timesOnTrk1_; + TH1F* timesOffTrk1_; + TH1F* timesNTD1_; + TH1F* timesOnTrkNTD1_; + TH1F* timesOffTrkNTD1_; + + //FOR THE SECOND FILE + + TH1F* layers2_; + TH1F* layersOnTrk2_; + TH1F* layersOffTrk2_; + TH1F* charges2_; + TH1F* chargesOnTrk2_; + TH1F* chargesOffTrk2_; + + TH1F* layersNTD2_; + TH1F* layersOnTrkNTD2_; + TH1F* layersOffTrkNTD2_; + TH1F* chargesNTD2_; + TH1F* chargesOnTrkNTD2_; + TH1F* chargesOffTrkNTD2_; + + TH1F* positions2_; + TH1F* positionsOnTrk2_; + TH1F* ClusDistances2_; + TH1F* ClusDistancesNTD2_; + + TH1F* times2_; + TH1F* timesOnTrk2_; + TH1F* timesOffTrk2_; + TH1F* timesNTD2_; + TH1F* timesOnTrkNTD2_; + TH1F* timesOffTrkNTD2_; + + //TRACKING RELATED VARIABLES + + TH2F* Z0VNShare2Hist1_; + TH2F* Z0VNShare2HistCut1_; + TH1F* SharedAmplitudes1_; + TH1F* UnSharedAmplitudes1_; + TH1F* SharedTimes1_; + TH1F* UnSharedTimes1_; + TH1F* TrackMomentumInTime1_; + TH1F* TrackMomentumOutTime1_; + TH1F* TrackMomentumAllTime1_; + TH1F* TrackMomentumTInTime1_; + TH1F* TrackMomentumTOutTime1_; + TH1F* TrackMomentumTAllTime1_; + + TH2F* Z0VNShare2Hist2_; + TH2F* Z0VNShare2HistCut2_; + TH1F* SharedAmplitudes2_; + TH1F* UnSharedAmplitudes2_; + TH1F* SharedTimes2_; + TH1F* UnSharedTimes2_; + TH1F* TrackMomentumInTime2_; + TH1F* TrackMomentumOutTime2_; + TH1F* TrackMomentumAllTime2_; + TH1F* TrackMomentumTInTime2_; + TH1F* TrackMomentumTOutTime2_; + TH1F* TrackMomentumTAllTime2_; + + float pcut_{-1.0}; + + bool doingTracks_{false}; + + float Deads_[24576]; + + std::vector * Clusters_{}; + std::vector * ClustersKF_{}; + std::vector * svtraw_{}; + std::vector * tracks_{}; + + + //std::string anaName_{"roryClusterAna"}; + int debug_{0}; + int isMC_{0}; + float ident_{1.0}; +}; + +#endif diff --git a/processors/include/SvtRawDataAnaProcessor.h b/processors/include/SvtRawDataAnaProcessor.h index 00616e717..0b782e6d2 100644 --- a/processors/include/SvtRawDataAnaProcessor.h +++ b/processors/include/SvtRawDataAnaProcessor.h @@ -48,6 +48,8 @@ class SvtRawDataAnaProcessor : public Processor { virtual void initialize(TTree* tree); virtual void sample(RawSvtHit* thisHit, std::string word, IEvent* ievent, long t,int i); + + //virtual int hitEff(IEvent* ievent, int L); virtual TF1* fourPoleFitFunction(std::string word, int caser); @@ -86,15 +88,23 @@ class SvtRawDataAnaProcessor : public Processor { TBranch* brecoClu_{nullptr}; TBranch* bPart_{nullptr}; TBranch* bTrk_{nullptr}; + TBranch* bClusters_{nullptr}; TBranch* bevH_; - + /* + TTree *HitEff_; + //TBranch* bL1_{nullptr}; + int L1_; + bool doHitEff_{false}; + */ std::vector * svtHits_{}; VTPData * vtpBank_; TSData * tsBank_; std::vector* recoClu_{}; std::vector* Trk_{}; std::vector* Part_{}; + std::vector* Clusters_{}; + //std::vector Trk_{}; EventHeader * evH_; From fcd26f8a06acbe3ce4a281c2b6c8a5c85d20b6b3 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 10:37:27 -0800 Subject: [PATCH 03/70] Add files via upload --- processors/config/roryClusterAna.py | 56 ++++++++++++++++++++++ processors/config/roryClusterCompareAna.py | 56 ++++++++++++++++++++++ 2 files changed, 112 insertions(+) create mode 100644 processors/config/roryClusterAna.py create mode 100644 processors/config/roryClusterCompareAna.py diff --git a/processors/config/roryClusterAna.py b/processors/config/roryClusterAna.py new file mode 100644 index 000000000..812db21e7 --- /dev/null +++ b/processors/config/roryClusterAna.py @@ -0,0 +1,56 @@ +import HpstrConf +import sys +import baseConfig as base +from baseConfig import bfield + +base.parser.add_argument("-L", "--layer", type=int, dest="layer", + help="Layer Under Investigation", metavar="layer",default=-1) +base.parser.add_argument("-M", "--module", type=int, dest="module", + help="Module Under Investigation", metavar="module",default=-1) +base.parser.add_argument("-MC", "--MC", type=int, dest="isMC", + help="IS IT MC", metavar="module",default=0) +base.parser.add_argument("-doT", "--doT", type=int, dest="doTrack", + help="DO WE DO TRACK STUFF", metavar="doTrack",default=0) +base.parser.add_argument("-cut", "--cut", type=float, dest="cut", + help="Momentum Cut for NShared Profile", metavar="cut",default=-1.0) + + +options = base.parser.parse_args() + +# Use the input file to set the output file name +root_file = options.inFilename +ana_file = options.outFilename + +#print('LCIO file: %s' % root_file) +#print('Root file: %s' % ana_file) + +p = HpstrConf.Process() + +#p.max_events = 1000 +p.run_mode = 1 +p.skip_events = options.skip_events +p.max_events = options.nevents + +# Library containing processors +p.add_library("libprocessors") + +############################### +# Processors # +############################### +rclu = HpstrConf.Processor('rclu','RoryClusterAnaProcessor') +rclu.parameters["debug"] = 0 +rclu.parameters["layer"] = options.layer +rclu.parameters["module"] = options.module +rclu.parameters["isMC"] = options.isMC +rclu.parameters["doTrack"] = options.doTrack +rclu.parameters["cut"] = options.cut + +sequence = [rclu] + +p.sequence = sequence + +print("THE INPUT FILE IS "+str(root_file)) +p.input_files = root_file +p.output_files = [ana_file] + +p.printProcess() diff --git a/processors/config/roryClusterCompareAna.py b/processors/config/roryClusterCompareAna.py new file mode 100644 index 000000000..467085574 --- /dev/null +++ b/processors/config/roryClusterCompareAna.py @@ -0,0 +1,56 @@ +import HpstrConf +import sys +import baseConfig as base +from baseConfig import bfield + +base.parser.add_argument("-L", "--layer", type=int, dest="layer", + help="Layer Under Investigation", metavar="layer",default=-1) +base.parser.add_argument("-M", "--module", type=int, dest="module", + help="Module Under Investigation", metavar="module",default=-1) +base.parser.add_argument("-MC", "--MC", type=int, dest="isMC", + help="IS IT MC", metavar="module",default=0) +base.parser.add_argument("-doT", "--doT", type=int, dest="doTrack", + help="DO WE DO TRACK STUFF", metavar="doTrack",default=0) +base.parser.add_argument("-cut", "--cut", type=float, dest="cut", + help="Momentum Cut for NShared Profile", metavar="cut",default=-1.0) + + +options = base.parser.parse_args() + +# Use the input file to set the output file name +root_file = options.inFilename +ana_file = options.outFilename + +#print('LCIO file: %s' % root_file) +#print('Root file: %s' % ana_file) + +p = HpstrConf.Process() + +#p.max_events = 1000 +p.run_mode = 1 +p.skip_events = options.skip_events +p.max_events = options.nevents + +# Library containing processors +p.add_library("libprocessors") + +############################### +# Processors # +############################### +rcclu = HpstrConf.Processor('rclu','RoryClusterCompareAnaProcessor') +rcclu.parameters["debug"] = 0 +rcclu.parameters["layer"] = options.layer +rcclu.parameters["module"] = options.module +rcclu.parameters["isMC"] = options.isMC +rcclu.parameters["doTrack"] = options.doTrack +rcclu.parameters["cut"] = options.cut + +sequence = [rcclu] + +p.sequence = sequence + +print("THE INPUT FILE IS "+str(root_file)) +p.input_files = root_file +p.output_files = [ana_file] + +p.printProcess() From 23345663898655d338c827653ec66eeeb7a0d610 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 11:45:30 -0800 Subject: [PATCH 04/70] Update and rename RoryClusterAnaProcessor.cxx to ClusterAnaProcessor.cxx --- ...aProcessor.cxx => ClusterAnaProcessor.cxx} | 42 +++++++++---------- 1 file changed, 21 insertions(+), 21 deletions(-) rename processors/src/{RoryClusterAnaProcessor.cxx => ClusterAnaProcessor.cxx} (96%) diff --git a/processors/src/RoryClusterAnaProcessor.cxx b/processors/src/ClusterAnaProcessor.cxx similarity index 96% rename from processors/src/RoryClusterAnaProcessor.cxx rename to processors/src/ClusterAnaProcessor.cxx index 7f067e1c6..c0a987717 100644 --- a/processors/src/RoryClusterAnaProcessor.cxx +++ b/processors/src/ClusterAnaProcessor.cxx @@ -1,20 +1,20 @@ /** - * @file RoryClusterAnaProcessor.cxx + * @file ClusterAnaProcessor.cxx * @brief AnaProcessor used fill histograms to study svt hit fitting * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory */ -#include "RoryClusterAnaProcessor.h" +#include "ClusterAnaProcessor.h" //#include "Int_t.h" #include -RoryClusterAnaProcessor::RoryClusterAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ +ClusterAnaProcessor::ClusterAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ mmapper_ = new ModuleMapper(2021); } //TODO CHECK THIS DESTRUCTOR -RoryClusterAnaProcessor::~RoryClusterAnaProcessor(){} +ClusterAnaProcessor::~ClusterAnaProcessor(){} -void RoryClusterAnaProcessor::configure(const ParameterSet& parameters) { - std::cout << "Configuring RoryClusterAnaProcessor" << std::endl; +void ClusterAnaProcessor::configure(const ParameterSet& parameters) { + std::cout << "Configuring ClusterAnaProcessor" << std::endl; try { debug_ = parameters.getInteger("debug"); @@ -33,7 +33,7 @@ void RoryClusterAnaProcessor::configure(const ParameterSet& parameters) { } -void RoryClusterAnaProcessor::initialize(TTree* tree) { +void ClusterAnaProcessor::initialize(TTree* tree) { fillDeads(); tree_= tree; //tree_->Print(); @@ -115,7 +115,7 @@ void RoryClusterAnaProcessor::initialize(TTree* tree) { std::cout<<"I GET HERE 2"<size()<<" hits"<SetLogy(true); @@ -332,7 +332,7 @@ void RoryClusterAnaProcessor::Plot1(){ return; } -void RoryClusterAnaProcessor::Plot2(){ +void ClusterAnaProcessor::Plot2(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -378,7 +378,7 @@ void RoryClusterAnaProcessor::Plot2(){ return; } -void RoryClusterAnaProcessor::Plot3(){ +void ClusterAnaProcessor::Plot3(){ std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); @@ -424,7 +424,7 @@ void RoryClusterAnaProcessor::Plot3(){ return; } -void RoryClusterAnaProcessor::Plot4(){ +void ClusterAnaProcessor::Plot4(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -470,7 +470,7 @@ void RoryClusterAnaProcessor::Plot4(){ return; } -void RoryClusterAnaProcessor::Plot5(){ +void ClusterAnaProcessor::Plot5(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -513,7 +513,7 @@ void RoryClusterAnaProcessor::Plot5(){ c1->Clear(); } -void RoryClusterAnaProcessor::Plot6(){ +void ClusterAnaProcessor::Plot6(){ std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); @@ -559,7 +559,7 @@ void RoryClusterAnaProcessor::Plot6(){ return; } -void RoryClusterAnaProcessor::Plot7(){ +void ClusterAnaProcessor::Plot7(){ std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); @@ -605,7 +605,7 @@ void RoryClusterAnaProcessor::Plot7(){ return; } -void RoryClusterAnaProcessor::TrackPlot1(){ +void ClusterAnaProcessor::TrackPlot1(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); //FIRST I DO THE PROFILES OF THE NSHARED HITS PLOTS @@ -656,11 +656,11 @@ void RoryClusterAnaProcessor::TrackPlot1(){ return; } -/*void RoryClusterAnaProcessor::ClusterFit(){ +/*void ClusterAnaProcessor::ClusterFit(){ return; }*/ -void RoryClusterAnaProcessor::finalize() { +void ClusterAnaProcessor::finalize() { Plot1(); Plot2(); Plot3(); @@ -674,4 +674,4 @@ void RoryClusterAnaProcessor::finalize() { //ClusterFit(); return; } -DECLARE_PROCESSOR(RoryClusterAnaProcessor); +DECLARE_PROCESSOR(ClusterAnaProcessor); From bb58bfb8f1d5adba49d794b8859afdc184f0d1d6 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 11:46:32 -0800 Subject: [PATCH 05/70] Update and rename RoryClusterAnaProcessor.h to ClusterAnaProcessor.h --- ...ryClusterAnaProcessor.h => ClusterAnaProcessor.h} | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) rename processors/include/{RoryClusterAnaProcessor.h => ClusterAnaProcessor.h} (91%) diff --git a/processors/include/RoryClusterAnaProcessor.h b/processors/include/ClusterAnaProcessor.h similarity index 91% rename from processors/include/RoryClusterAnaProcessor.h rename to processors/include/ClusterAnaProcessor.h index 49ce34a67..bc3777e31 100644 --- a/processors/include/RoryClusterAnaProcessor.h +++ b/processors/include/ClusterAnaProcessor.h @@ -1,5 +1,5 @@ -#ifndef __RORYCLUSTER_ANAPROCESSOR_H__ -#define __RORYCLUSTER_ANAPROCESSOR_H__ +#ifndef __CLUSTER_ANAPROCESSOR_H__ +#define __CLUSTER_ANAPROCESSOR_H__ //HPSTR #include "HpsEvent.h" @@ -37,13 +37,13 @@ class TTree; -class RoryClusterAnaProcessor : public Processor { +class ClusterAnaProcessor : public Processor { public: - RoryClusterAnaProcessor(const std::string& name, Process& process); + ClusterAnaProcessor(const std::string& name, Process& process); - ~RoryClusterAnaProcessor(); + ~ClusterAnaProcessor(); virtual bool process(IEvent* ievent); @@ -149,7 +149,7 @@ class RoryClusterAnaProcessor : public Processor { std::vector * tracks_{}; - //std::string anaName_{"roryClusterAna"}; + //std::string anaName_{"ClusterAna"}; int debug_{0}; int isMC_{0}; }; From c078393fa06514bdbfcabf4f89a9b2b3a3be7ba7 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 11:48:44 -0800 Subject: [PATCH 06/70] Update RoryClusterCompareAnaProcessor.cxx --- .../src/RoryClusterCompareAnaProcessor.cxx | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/processors/src/RoryClusterCompareAnaProcessor.cxx b/processors/src/RoryClusterCompareAnaProcessor.cxx index fbce55d2c..a0306e663 100644 --- a/processors/src/RoryClusterCompareAnaProcessor.cxx +++ b/processors/src/RoryClusterCompareAnaProcessor.cxx @@ -1,20 +1,20 @@ /** - * @file RoryClusterCompareAnaProcessor.cxx + * @file ClusterCompareAnaProcessor.cxx * @brief AnaProcessor used to compare two means of reconstruction directly. * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory */ -#include "RoryClusterCompareAnaProcessor.h" +#include "ClusterCompareAnaProcessor.h" //#include "Int_t.h" #include -RoryClusterCompareAnaProcessor::RoryClusterCompareAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ +ClusterCompareAnaProcessor::ClusterCompareAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ mmapper_ = new ModuleMapper(2021); } //TODO CHECK THIS DESTRUCTOR -RoryClusterCompareAnaProcessor::~RoryClusterCompareAnaProcessor(){} +ClusterCompareAnaProcessor::~ClusterCompareAnaProcessor(){} -void RoryClusterCompareAnaProcessor::configure(const ParameterSet& parameters) { - std::cout << "Configuring RoryClusterCompareAnaProcessor" << std::endl; +void ClusterCompareAnaProcessor::configure(const ParameterSet& parameters) { + std::cout << "Configuring ClusterCompareAnaProcessor" << std::endl; try { debug_ = parameters.getInteger("debug"); @@ -33,7 +33,7 @@ void RoryClusterCompareAnaProcessor::configure(const ParameterSet& parameters) { } -void RoryClusterCompareAnaProcessor::initialize(TTree* tree) { +void ClusterCompareAnaProcessor::initialize(TTree* tree) { fillDeads(); tree_= tree; //tree_->Print(); @@ -172,7 +172,7 @@ void RoryClusterCompareAnaProcessor::initialize(TTree* tree) { std::cout<<"I GET HERE 2"<size()<<" hits"<1.0){std::cout<SetLogy(true); @@ -423,7 +423,7 @@ void RoryClusterCompareAnaProcessor::Plot1(){ return; } -void RoryClusterCompareAnaProcessor::Plot2(){ +void ClusterCompareAnaProcessor::Plot2(){ TCanvas *c1 = new TCanvas("c"); //gPad->SetLogy(true); c1->cd(); @@ -482,7 +482,7 @@ void RoryClusterCompareAnaProcessor::Plot2(){ return; } -void RoryClusterCompareAnaProcessor::Plot3(){ +void ClusterCompareAnaProcessor::Plot3(){ std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); @@ -543,7 +543,7 @@ void RoryClusterCompareAnaProcessor::Plot3(){ return; } -void RoryClusterCompareAnaProcessor::Plot4(){ +void ClusterCompareAnaProcessor::Plot4(){ std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); @@ -599,7 +599,7 @@ void RoryClusterCompareAnaProcessor::Plot4(){ return; } -void RoryClusterCompareAnaProcessor::TrackPlot1(){ +void ClusterCompareAnaProcessor::TrackPlot1(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); gPad->SetLogy(false); @@ -651,7 +651,7 @@ void RoryClusterCompareAnaProcessor::TrackPlot1(){ return; } -void RoryClusterCompareAnaProcessor::TrackPlot2(){ +void ClusterCompareAnaProcessor::TrackPlot2(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); gPad->SetLogy(false); @@ -702,7 +702,7 @@ void RoryClusterCompareAnaProcessor::TrackPlot2(){ return; } -void RoryClusterCompareAnaProcessor::finalize() { +void ClusterCompareAnaProcessor::finalize() { Plot1(); Plot2(); Plot3(); @@ -714,4 +714,4 @@ void RoryClusterCompareAnaProcessor::finalize() { //ClusterFit(); return; } -DECLARE_PROCESSOR(RoryClusterCompareAnaProcessor); +DECLARE_PROCESSOR(ClusterCompareAnaProcessor); From 0c9dc32be60e7487d1fb126e38bfead24f351549 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 11:51:05 -0800 Subject: [PATCH 07/70] Rename RoryClusterCompareAnaProcessor.cxx to ClusterCompareAnaProcessor.cxx --- ...sterCompareAnaProcessor.cxx => ClusterCompareAnaProcessor.cxx} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename processors/src/{RoryClusterCompareAnaProcessor.cxx => ClusterCompareAnaProcessor.cxx} (100%) diff --git a/processors/src/RoryClusterCompareAnaProcessor.cxx b/processors/src/ClusterCompareAnaProcessor.cxx similarity index 100% rename from processors/src/RoryClusterCompareAnaProcessor.cxx rename to processors/src/ClusterCompareAnaProcessor.cxx From 57dda9c5781ccadb7b731ffa7f02672e38e7c3e9 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 11:53:18 -0800 Subject: [PATCH 08/70] Update and rename RoryClusterCompareAnaProcessor.h to ClusterCompareAnaProcessor.h --- ...rocessor.h => ClusterCompareAnaProcessor.h} | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) rename processors/include/{RoryClusterCompareAnaProcessor.h => ClusterCompareAnaProcessor.h} (90%) diff --git a/processors/include/RoryClusterCompareAnaProcessor.h b/processors/include/ClusterCompareAnaProcessor.h similarity index 90% rename from processors/include/RoryClusterCompareAnaProcessor.h rename to processors/include/ClusterCompareAnaProcessor.h index 96f1f4026..c9445f9a3 100644 --- a/processors/include/RoryClusterCompareAnaProcessor.h +++ b/processors/include/ClusterCompareAnaProcessor.h @@ -1,5 +1,5 @@ -#ifndef __RORYCLUSTERCOMPARE_ANAPROCESSOR_H__ -#define __RORYCLUSTERCOMPARE_ANAPROCESSOR_H__ +#ifndef __CLUSTERCOMPARE_ANAPROCESSOR_H__ +#define __CLUSTERCOMPARE_ANAPROCESSOR_H__ //HPSTR #include "HpsEvent.h" @@ -37,13 +37,13 @@ class TTree; -class RoryClusterCompareAnaProcessor : public Processor { +class ClusterCompareAnaProcessor : public Processor { public: - RoryClusterCompareAnaProcessor(const std::string& name, Process& process); + ClusterCompareAnaProcessor(const std::string& name, Process& process); - ~RoryClusterCompareAnaProcessor(); + ~ClusterCompareAnaProcessor(); virtual bool process(IEvent* ievent); @@ -57,12 +57,6 @@ class RoryClusterCompareAnaProcessor : public Processor { virtual void Plot4(); - //virtual void Plot5(); - - //virtual void Plot6(); - - //virtual void Plot7(); - virtual void TrackPlot1(); virtual void TrackPlot2(); @@ -187,7 +181,7 @@ class RoryClusterCompareAnaProcessor : public Processor { std::vector * tracks_{}; - //std::string anaName_{"roryClusterAna"}; + //std::string anaName_{"ClusterAna"}; int debug_{0}; int isMC_{0}; float ident_{1.0}; From d83ce7c681c91d67e5083bd8946b3fdfe3aeb41a Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 11:55:09 -0800 Subject: [PATCH 09/70] Update and rename roryClusterAna.py to ClusterAna.py --- .../{roryClusterAna.py => ClusterAna.py} | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) rename processors/config/{roryClusterAna.py => ClusterAna.py} (76%) diff --git a/processors/config/roryClusterAna.py b/processors/config/ClusterAna.py similarity index 76% rename from processors/config/roryClusterAna.py rename to processors/config/ClusterAna.py index 812db21e7..53d5afcb9 100644 --- a/processors/config/roryClusterAna.py +++ b/processors/config/ClusterAna.py @@ -10,7 +10,7 @@ base.parser.add_argument("-MC", "--MC", type=int, dest="isMC", help="IS IT MC", metavar="module",default=0) base.parser.add_argument("-doT", "--doT", type=int, dest="doTrack", - help="DO WE DO TRACK STUFF", metavar="doTrack",default=0) + help="We plot the tracking based cluster performance metrics", metavar="doTrack",default=0) base.parser.add_argument("-cut", "--cut", type=float, dest="cut", help="Momentum Cut for NShared Profile", metavar="cut",default=-1.0) @@ -37,15 +37,15 @@ ############################### # Processors # ############################### -rclu = HpstrConf.Processor('rclu','RoryClusterAnaProcessor') -rclu.parameters["debug"] = 0 -rclu.parameters["layer"] = options.layer -rclu.parameters["module"] = options.module -rclu.parameters["isMC"] = options.isMC -rclu.parameters["doTrack"] = options.doTrack -rclu.parameters["cut"] = options.cut - -sequence = [rclu] +clua = HpstrConf.Processor('clua','ClusterAnaProcessor') +clua.parameters["debug"] = 0 +clua.parameters["layer"] = options.layer +clua.parameters["module"] = options.module +clua.parameters["isMC"] = options.isMC +clua.parameters["doTrack"] = options.doTrack +clua.parameters["cut"] = options.cut + +sequence = [clua] p.sequence = sequence From c13425de73493ccf56ea861acdc3dce36cd3f6f6 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 11:55:36 -0800 Subject: [PATCH 10/70] Rename ClusterAna.py to clusterAna.py --- processors/config/{ClusterAna.py => clusterAna.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename processors/config/{ClusterAna.py => clusterAna.py} (100%) diff --git a/processors/config/ClusterAna.py b/processors/config/clusterAna.py similarity index 100% rename from processors/config/ClusterAna.py rename to processors/config/clusterAna.py From f3fdf0f75420869893a4dc669f4243a1f4729375 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 11:56:40 -0800 Subject: [PATCH 11/70] Update and rename roryClusterCompareAna.py to clusterCompareAna.py --- ...sterCompareAna.py => clusterCompareAna.py} | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) rename processors/config/{roryClusterCompareAna.py => clusterCompareAna.py} (75%) diff --git a/processors/config/roryClusterCompareAna.py b/processors/config/clusterCompareAna.py similarity index 75% rename from processors/config/roryClusterCompareAna.py rename to processors/config/clusterCompareAna.py index 467085574..1e010c679 100644 --- a/processors/config/roryClusterCompareAna.py +++ b/processors/config/clusterCompareAna.py @@ -10,7 +10,7 @@ base.parser.add_argument("-MC", "--MC", type=int, dest="isMC", help="IS IT MC", metavar="module",default=0) base.parser.add_argument("-doT", "--doT", type=int, dest="doTrack", - help="DO WE DO TRACK STUFF", metavar="doTrack",default=0) + help="we plot tracking related cluster performance metrics", metavar="doTrack",default=0) base.parser.add_argument("-cut", "--cut", type=float, dest="cut", help="Momentum Cut for NShared Profile", metavar="cut",default=-1.0) @@ -37,15 +37,15 @@ ############################### # Processors # ############################### -rcclu = HpstrConf.Processor('rclu','RoryClusterCompareAnaProcessor') -rcclu.parameters["debug"] = 0 -rcclu.parameters["layer"] = options.layer -rcclu.parameters["module"] = options.module -rcclu.parameters["isMC"] = options.isMC -rcclu.parameters["doTrack"] = options.doTrack -rcclu.parameters["cut"] = options.cut - -sequence = [rcclu] +cclua = HpstrConf.Processor('cclua','ClusterCompareAnaProcessor') +cclua.parameters["debug"] = 0 +cclua.parameters["layer"] = options.layer +cclua.parameters["module"] = options.module +cclua.parameters["isMC"] = options.isMC +cclua.parameters["doTrack"] = options.doTrack +cclua.parameters["cut"] = options.cut + +sequence = [cclua] p.sequence = sequence From 00214c41c7a4dd50a442075fddff9cedc14bdbce Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 12:08:43 -0800 Subject: [PATCH 12/70] Update ClusterAnaProcessor.cxx --- processors/src/ClusterAnaProcessor.cxx | 82 +++++++------------------- 1 file changed, 20 insertions(+), 62 deletions(-) diff --git a/processors/src/ClusterAnaProcessor.cxx b/processors/src/ClusterAnaProcessor.cxx index c0a987717..0b34f5d77 100644 --- a/processors/src/ClusterAnaProcessor.cxx +++ b/processors/src/ClusterAnaProcessor.cxx @@ -1,16 +1,14 @@ /** * @file ClusterAnaProcessor.cxx - * @brief AnaProcessor used fill histograms to study svt hit fitting + * @brief AnaProcessor used fill histograms to study cluster reconstruction algorithms and dead channels. * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory */ #include "ClusterAnaProcessor.h" -//#include "Int_t.h" #include ClusterAnaProcessor::ClusterAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ mmapper_ = new ModuleMapper(2021); } -//TODO CHECK THIS DESTRUCTOR ClusterAnaProcessor::~ClusterAnaProcessor(){} void ClusterAnaProcessor::configure(const ParameterSet& parameters) { @@ -36,7 +34,6 @@ void ClusterAnaProcessor::configure(const ParameterSet& parameters) { void ClusterAnaProcessor::initialize(TTree* tree) { fillDeads(); tree_= tree; - //tree_->Print(); if(isMC_==1){ layers_=new TH1F("layers","MC Strip Width for All Clusters",12,0.0,12.0); @@ -65,11 +62,9 @@ void ClusterAnaProcessor::initialize(TTree* tree) { timesOnTrkNTD_=new TH1F("TimesOnTrkNTD","MC Time of On Track Cluster Hit NTD",1000,-60.0,60.0); timesOffTrkNTD_=new TH1F("TimesOffTrkNTD","MC Time of Off Cluster Hit NTD",1000,-60.0,60.0); - std::cout<<"I GET HERE 1"<SetBranchAddress("SiClusters",&Clusters_,&bClusters_); tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); - std::cout<<"I GET HERE 2"<SetBranchAddress("SiClusters",&Clusters_,&bClusters_); tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); if(doingTracks_){ tree_->SetBranchAddress("KalmanFullTracks",&tracks_,&btracks_); } - std::cout<<"I GET HERE 2"<size()<<" hits"<size();i++){ Track* track = tracks_->at(i); @@ -175,12 +166,6 @@ bool ClusterAnaProcessor::process(IEvent* ievent) { float nLayers = (float)(clu->getRawHits().GetEntries()); float ncharges = (float)(clu->getCharge()); float ntimes = (float)(clu->getTime()); - //float ntimes = 0.0; - //for(int p = 0;pgetRawHits().GetEntries();p++){ - // RawSvtHit * holder = (RawSvtHit*)(clu->getRawHits().At(p)); - // ntimes+=holder->getT0(0); - //} - //ntimes=gtimes;//%ncharges; bool onTrk = false; bool NTD = false; for(unsigned int j = 0; j < ClustersKF_->size(); j++){ @@ -188,13 +173,11 @@ bool ClusterAnaProcessor::process(IEvent* ievent) { onTrk = true; } } - //std::cout<getVolume()<getHwFromSw(input); - //std::cout<SetLogy(true); c1->cd(); @@ -300,8 +282,6 @@ void ClusterAnaProcessor::Plot1(){ c1->DrawFrame(0.0,3000.0,150.0,7000.0); c1->SetTitle("Layers for All Clusters"); - //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); c1->SaveAs("allClusters.png"); c1->Clear(); @@ -332,7 +312,7 @@ void ClusterAnaProcessor::Plot1(){ return; } -void ClusterAnaProcessor::Plot2(){ +void ClusterAnaProcessor::PlotClusterCharges(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -346,8 +326,6 @@ void ClusterAnaProcessor::Plot2(){ c1->DrawFrame(0.0,3000.0,150.0,7000.0); c1->SetTitle("Charges for All Clusters"); - //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); c1->SaveAs("allClustersCharge.png"); c1->Clear(); @@ -377,9 +355,8 @@ void ClusterAnaProcessor::Plot2(){ c1->Clear(); return; } - -void ClusterAnaProcessor::Plot3(){ - std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); c1->cd(); @@ -392,8 +369,6 @@ void ClusterAnaProcessor::Plot3(){ c1->DrawFrame(0.0,3000.0,150.0,7000.0); c1->SetTitle("NTD Layers for All Clusters"); - //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); c1->SaveAs("allClustersNTD.png"); c1->Clear(); @@ -424,7 +399,7 @@ void ClusterAnaProcessor::Plot3(){ return; } -void ClusterAnaProcessor::Plot4(){ +void ClusterAnaProcessor::PlotClusterChargesNTD(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -438,8 +413,6 @@ void ClusterAnaProcessor::Plot4(){ c1->DrawFrame(0.0,3000.0,150.0,7000.0); c1->SetTitle("NTD Charges for All Clusters"); - //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); c1->SaveAs("allClustersChargeNTD.png"); c1->Clear(); @@ -470,7 +443,7 @@ void ClusterAnaProcessor::Plot4(){ return; } -void ClusterAnaProcessor::Plot5(){ +void ClusterAnaProcessor::PlotClusterPositions(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -479,8 +452,6 @@ void ClusterAnaProcessor::Plot5(){ c1->DrawFrame(0.0,3000.0,150.0,7000.0); c1->SetTitle("Cluster Position for all Clusters"); - //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); c1->SaveAs("positions.png"); c1->Clear(); @@ -488,10 +459,7 @@ void ClusterAnaProcessor::Plot5(){ positionsOnTrk_->GetXaxis()->SetTitle("Layer"); positionsOnTrk_->GetYaxis()->SetTitle("Hits"); - //c1->DrawFrame(0.0,3000.0,150.0,7000.0); c1->SetTitle("Cluster Position for NTD Clusters"); - //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); c1->SaveAs("positionsNTD.png"); c1->Clear(); @@ -513,8 +481,7 @@ void ClusterAnaProcessor::Plot5(){ c1->Clear(); } -void ClusterAnaProcessor::Plot6(){ - std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); c1->cd(); @@ -527,8 +494,6 @@ void ClusterAnaProcessor::Plot6(){ c1->DrawFrame(0.0,3000.0,150.0,7000.0); c1->SetTitle("Times for All Clusters"); - //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw(); c1->SaveAs("alltimes.png"); c1->Clear(); @@ -559,8 +524,7 @@ void ClusterAnaProcessor::Plot6(){ return; } -void ClusterAnaProcessor::Plot7(){ - std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); c1->cd(); @@ -573,8 +537,6 @@ void ClusterAnaProcessor::Plot7(){ c1->DrawFrame(0.0,3000.0,150.0,7000.0); c1->SetTitle("Times for All Clusters"); - //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); c1->SaveAs("alltimesNTD.png"); c1->Clear(); @@ -605,7 +567,7 @@ void ClusterAnaProcessor::Plot7(){ return; } -void ClusterAnaProcessor::TrackPlot1(){ +void ClusterAnaProcessor::TrackPlot(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); //FIRST I DO THE PROFILES OF THE NSHARED HITS PLOTS @@ -655,21 +617,17 @@ void ClusterAnaProcessor::TrackPlot1(){ c1->Clear(); return; } - -/*void ClusterAnaProcessor::ClusterFit(){ - return; -}*/ void ClusterAnaProcessor::finalize() { - Plot1(); - Plot2(); - Plot3(); - Plot4(); - Plot5(); - Plot6(); - Plot7(); + PlotClusterLayers(); + PlotClusterLayersNTD(); + PlotClusterCharges(); + PlotClusterChargesNTD(); + PlotClusterPositions(); + PlotClusterTimes(); + PlotClusterTimesNTD(); if(doingTracks_){ - TrackPlot1(); + TrackPlot(); } //ClusterFit(); return; From 583d12e063035869b23d9f949741ec2055c31045 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 12:09:20 -0800 Subject: [PATCH 13/70] Update ClusterAnaProcessor.cxx --- processors/src/ClusterAnaProcessor.cxx | 1 - 1 file changed, 1 deletion(-) diff --git a/processors/src/ClusterAnaProcessor.cxx b/processors/src/ClusterAnaProcessor.cxx index 0b34f5d77..8cafbf4f2 100644 --- a/processors/src/ClusterAnaProcessor.cxx +++ b/processors/src/ClusterAnaProcessor.cxx @@ -629,7 +629,6 @@ void ClusterAnaProcessor::finalize() { if(doingTracks_){ TrackPlot(); } - //ClusterFit(); return; } DECLARE_PROCESSOR(ClusterAnaProcessor); From 5ef8bc1a3c329e45f2613f9214f8c8ba19e85686 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 12:11:09 -0800 Subject: [PATCH 14/70] Update ClusterAnaProcessor.h --- processors/include/ClusterAnaProcessor.h | 34 +++++++----------------- 1 file changed, 10 insertions(+), 24 deletions(-) diff --git a/processors/include/ClusterAnaProcessor.h b/processors/include/ClusterAnaProcessor.h index bc3777e31..c8e95ed46 100644 --- a/processors/include/ClusterAnaProcessor.h +++ b/processors/include/ClusterAnaProcessor.h @@ -48,40 +48,26 @@ class ClusterAnaProcessor : public Processor { virtual bool process(IEvent* ievent); virtual void initialize(TTree* tree); - - virtual void Plot1(); - - virtual void Plot2(); - - virtual void Plot3(); - - virtual void Plot4(); - virtual void Plot5(); + virtual void PlotClusterLayers(); - virtual void Plot6(); + virtual void PlotClusterLayersNTD(); - virtual void Plot7(); + virtual void PlotClusterCharges(); - virtual void TrackPlot1(); + virtual void PlotClusterChargesNTD(); - //virtual void ClusterFit(); + virtual void PlotClusterPositions(); - virtual void fillDeads(); + virtual void PlotClusterTimes(); - virtual int GetStrip(int feb, int hyb,int strip); + virtual void PlotClusterTimesNTD(); - //virtual void sample(RawSvtHit* thisHit, std::string word, IEvent* ievent, long t,int i); - - //virtual int hitEff(IEvent* ievent, int L); - - //virtual TF1* fourPoleFitFunction(std::string word, int caser); - - //virtual float str_to_float(std::string word); + virtual void TrackPlot1(); - //float reverseEngineerTime(float ti, long t); + virtual void fillDeads(); - //virtual int maximum(int arr[]); + virtual int GetStrip(int feb, int hyb,int strip); virtual void finalize(); From b394c051945e061c25faa8424fc5c354edd8bce1 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 12:18:01 -0800 Subject: [PATCH 15/70] Update ClusterCompareAnaProcessor.cxx --- processors/src/ClusterCompareAnaProcessor.cxx | 77 +++++-------------- 1 file changed, 21 insertions(+), 56 deletions(-) diff --git a/processors/src/ClusterCompareAnaProcessor.cxx b/processors/src/ClusterCompareAnaProcessor.cxx index a0306e663..297669906 100644 --- a/processors/src/ClusterCompareAnaProcessor.cxx +++ b/processors/src/ClusterCompareAnaProcessor.cxx @@ -4,7 +4,6 @@ * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory */ #include "ClusterCompareAnaProcessor.h" -//#include "Int_t.h" #include ClusterCompareAnaProcessor::ClusterCompareAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ @@ -23,7 +22,6 @@ void ClusterCompareAnaProcessor::configure(const ParameterSet& parameters) { isMC_ = parameters.getInteger("isMC"); doingTracks_ = (parameters.getInteger("doTrack")==1); pcut_ = (float)parameters.getDouble("cut"); - //anaName_ = parameters.getString("anaName"); } catch (std::runtime_error& error) { @@ -35,9 +33,7 @@ void ClusterCompareAnaProcessor::configure(const ParameterSet& parameters) { void ClusterCompareAnaProcessor::initialize(TTree* tree) { fillDeads(); - tree_= tree; - //tree_->Print(); - + tree_= tree; if(isMC_==1){ layers1_=new TH1F("layers","MC Strip Width for All Clusters",12,0.0,12.0); layersOnTrk1_=new TH1F("layersOnTrk","MC Strip Width for Clusters on Track",12,0.0,12.0); @@ -65,11 +61,9 @@ void ClusterCompareAnaProcessor::initialize(TTree* tree) { timesOnTrkNTD1_=new TH1F("TimesOnTrkNTD","MC Time of On Track Cluster Hit NTD",1000,-60.0,60.0); timesOffTrkNTD1_=new TH1F("TimesOffTrkNTD","MC Time of Off Cluster Hit NTD",1000,-60.0,60.0); - std::cout<<"I GET HERE 1"<SetBranchAddress("SiClusters",&Clusters_,&bClusters_); tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); - std::cout<<"I GET HERE 2"<SetBranchAddress("SiClusters",&Clusters_,&bClusters_); tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); @@ -169,25 +162,18 @@ void ClusterCompareAnaProcessor::initialize(TTree* tree) { if(doingTracks_){ tree_->SetBranchAddress("KalmanFullTracks",&tracks_,&btracks_); } - std::cout<<"I GET HERE 2"<size()<<" hits"<1.0){std::cout<size();i++){ Track* track = tracks_->at(i); - //bool general = ((layer_==-1)||(module_==-1)); - //if(((LAYER==layer_)&&(MODULE==module_))||(general)){ - if(track->getTrackTime()*track->getTrackTime()<100.0){ - if(ident_<1.5){Z0VNShare2Hist1_->Fill(track->getZ0Err(),track->getNShared());}else{Z0VNShare2Hist2_->Fill(track->getZ0Err(),track->getNShared());} - if(track->getP()Fill(track->getZ0Err(),track->getNShared());}else{Z0VNShare2HistCut2_->Fill(track->getZ0Err(),track->getNShared());} - } + if(track->getTrackTime()*track->getTrackTime()<100.0){ + if(ident_<1.5){Z0VNShare2Hist1_->Fill(track->getZ0Err(),track->getNShared());}else{Z0VNShare2Hist2_->Fill(track->getZ0Err(),track->getNShared());} + if(track->getP()Fill(track->getZ0Err(),track->getNShared());}else{Z0VNShare2HistCut2_->Fill(track->getZ0Err(),track->getNShared());} } - //} + } //Track Momentum for In and Out of time hits (All not just transverse) if(ident_<1.5){TrackMomentumAllTime1_->Fill(track->getP());}else{TrackMomentumAllTime2_->Fill(track->getP());} @@ -251,12 +237,6 @@ bool ClusterCompareAnaProcessor::process(IEvent* ievent) { float nLayers = (float)(clu->getRawHits().GetEntries()); float ncharges = (float)(clu->getCharge()); float ntimes = (float)(clu->getTime()); - //float ntimes = 0.0; - //for(int p = 0;pgetRawHits().GetEntries();p++){ - // RawSvtHit * holder = (RawSvtHit*)(clu->getRawHits().At(p)); - // ntimes+=holder->getT0(0); - //} - //ntimes=gtimes;//%ncharges; bool onTrk = false; bool NTD = false; for(unsigned int j = 0; j < ClustersKF_->size(); j++){ @@ -264,13 +244,8 @@ bool ClusterCompareAnaProcessor::process(IEvent* ievent) { onTrk = true; } } - //std::cout<getVolume()<getHwFromSw(input); - //std::cout<Fill(Dist);}else{/*std::cout<<"1 "<Fill(Dist);} + if(ident_<1.5){ClusDistances1_->Fill(Dist);}else{ClusDistances2_->Fill(Dist);} if(NTD){if(ident_<1.5){ClusDistancesNTD1_->Fill(Dist);}else{ClusDistancesNTD2_->Fill(Dist);}} } - //std::cout<<"HELLO"<Fill(nLayers);}else{layers2_->Fill(nLayers);} if(ident_<1.5){charges1_->Fill(ncharges);}else{charges2_->Fill(ncharges);} - if(ident_<1.5){positions1_->Fill(clu->getLayer());}else{/*std::cout<<"2"<Fill(clu->getLayer());} + if(ident_<1.5){positions1_->Fill(clu->getLayer());}else{positions2_->Fill(clu->getLayer());} if(ident_<1.5){times1_->Fill(ntimes);}else{times2_->Fill(ntimes);} if(onTrk){ if(ident_<1.5){layersOnTrk1_->Fill(nLayers);}else{layersOnTrk2_->Fill(nLayers);} if(ident_<1.5){chargesOnTrk1_->Fill(ncharges);}else{chargesOnTrk2_->Fill(ncharges);} if(ident_<1.5){timesOnTrk1_->Fill(ntimes);}else{timesOnTrk2_->Fill(ntimes);} - if(ident_<1.5){positionsOnTrk1_->Fill(clu->getLayer());}else{positionsOnTrk2_->Fill(clu->getLayer());}//std::cout<<"3"<Fill(clu->getLayer());}else{positionsOnTrk2_->Fill(clu->getLayer());} }else{ if(ident_<1.5){layersOffTrk1_->Fill(nLayers);}else{layersOffTrk2_->Fill(nLayers);} if(ident_<1.5){chargesOffTrk1_->Fill(ncharges);}else{chargesOffTrk2_->Fill(ncharges);} @@ -362,8 +336,7 @@ int ClusterCompareAnaProcessor::GetStrip(int feb,int hyb,int strip){ return BigCount; } -void ClusterCompareAnaProcessor::Plot1(){ - std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); c1->cd(); @@ -390,8 +363,6 @@ void ClusterCompareAnaProcessor::Plot1(){ c1->DrawFrame(0.0,3000.0,150.0,7000.0); c1->SetTitle("Layers for All Clusters"); - //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); layers2_->Draw("e same"); auto legend1 = new TLegend(0.3,0.8,.68,.9); @@ -423,9 +394,8 @@ void ClusterCompareAnaProcessor::Plot1(){ return; } -void ClusterCompareAnaProcessor::Plot2(){ +void ClusterCompareAnaProcessor::PlotClusterCharges(){ TCanvas *c1 = new TCanvas("c"); - //gPad->SetLogy(true); c1->cd(); charges1_->GetXaxis()->SetTitle("Charge"); @@ -482,10 +452,8 @@ void ClusterCompareAnaProcessor::Plot2(){ return; } -void ClusterCompareAnaProcessor::Plot3(){ - std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); c1->cd(); times1_->GetXaxis()->SetTitle("Charge"); @@ -543,10 +511,8 @@ void ClusterCompareAnaProcessor::Plot3(){ return; } -void ClusterCompareAnaProcessor::Plot4(){ - std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); c1->cd(); positions1_->GetXaxis()->SetTitle("Position"); @@ -599,7 +565,7 @@ void ClusterCompareAnaProcessor::Plot4(){ return; } -void ClusterCompareAnaProcessor::TrackPlot1(){ +void ClusterCompareAnaProcessor::TrackMomenta(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); gPad->SetLogy(false); @@ -651,7 +617,7 @@ void ClusterCompareAnaProcessor::TrackPlot1(){ return; } -void ClusterCompareAnaProcessor::TrackPlot2(){ +void ClusterCompareAnaProcessor::TrackTransverseMomenta(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); gPad->SetLogy(false); @@ -703,15 +669,14 @@ void ClusterCompareAnaProcessor::TrackPlot2(){ } void ClusterCompareAnaProcessor::finalize() { - Plot1(); - Plot2(); - Plot3(); - Plot4(); + PlotClusterLayers(); + PlotClusterCharges(); + PlotClusterTimes(); + PlotClusterPositions(); if(doingTracks_){ - TrackPlot1(); - TrackPlot2(); + TrackMomenta()(); + TrackTransverseMomenta()(); } - //ClusterFit(); return; } DECLARE_PROCESSOR(ClusterCompareAnaProcessor); From 2a154377691e4d045b23e9a87a341f447c056023 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 12:20:22 -0800 Subject: [PATCH 16/70] Update ClusterCompareAnaProcessor.h --- processors/include/ClusterCompareAnaProcessor.h | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/processors/include/ClusterCompareAnaProcessor.h b/processors/include/ClusterCompareAnaProcessor.h index c9445f9a3..64fb4dc9c 100644 --- a/processors/include/ClusterCompareAnaProcessor.h +++ b/processors/include/ClusterCompareAnaProcessor.h @@ -48,18 +48,18 @@ class ClusterCompareAnaProcessor : public Processor { virtual bool process(IEvent* ievent); virtual void initialize(TTree* tree); + + virtual void PlotClusterLayers(); + + virtual void PlotClusterCharges(); - virtual void Plot1(); - - virtual void Plot2(); + virtual void PlotClusterTimes(); - virtual void Plot3(); + virtual void PlotClusterPositions(); - virtual void Plot4(); - - virtual void TrackPlot1(); + virtual void TrackMomenta(); - virtual void TrackPlot2(); + virtual void TrackTransverseMomenta(); virtual void fillDeads(); @@ -72,7 +72,6 @@ class ClusterCompareAnaProcessor : public Processor { private: //Containers to hold histogrammer info - //RawSvtHitHistos* histos{nullptr}; ModuleMapper * mmapper_; TTree* tree_; From 08173a710499528803fd7d0294a20cf2610d1e73 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 12:29:30 -0800 Subject: [PATCH 17/70] Update SvtRawDataAnaProcessor.cxx --- processors/src/SvtRawDataAnaProcessor.cxx | 242 +--------------------- 1 file changed, 11 insertions(+), 231 deletions(-) diff --git a/processors/src/SvtRawDataAnaProcessor.cxx b/processors/src/SvtRawDataAnaProcessor.cxx index f2652bb95..a97f4f02a 100644 --- a/processors/src/SvtRawDataAnaProcessor.cxx +++ b/processors/src/SvtRawDataAnaProcessor.cxx @@ -10,7 +10,6 @@ SvtRawDataAnaProcessor::SvtRawDataAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ mmapper_ = new ModuleMapper(); } -//TODO CHECK THIS DESTRUCTOR SvtRawDataAnaProcessor::~SvtRawDataAnaProcessor(){} @@ -62,11 +61,6 @@ float SvtRawDataAnaProcessor::str_to_float(std::string token){ return base; } -//float reverseEngineerTime(float ti,IEvent* ievent){ -// return ti-1.0; -//} - - float rETime(float ti,long T){ bool correctTimeOffset = true; bool subtractTriggerTime = true; @@ -75,43 +69,22 @@ float rETime(float ti,long T){ bool correctChanT0 = false; bool correctT0Shift = false; - - //bool subtractTOF = true; - - bool useTimestamps = false; - //sensor=hit.getSensor(); long OffsetTime = 35; long OffsetPhase = 4; long trigTimeOffset = 14; - //THIS ONE - //std::cout<<"Initial Time: "<0){ if(i<=4096){ @@ -210,30 +180,11 @@ void SvtRawDataAnaProcessor::initialize(TTree* tree) { tree_= tree; - //tree->Show(); - // init histos - //histos = new RawSvtHitHistos(anaName_.c_str(), mmapper_); - //histos->loadHistoConfig(histCfgFilename_); - //histos->DefineHistos(); - //std::cout<<"hello4"<size()<SetBranchAddress(svtHitColl_.c_str() , &svtHits_ , &bsvtHits_ ); - //tree_->SetBranchAddress("VTPBank", &vtpBank_ , &bvtpBank_ ); - //tree_->SetBranchAddress("TSBank", &tsBank_ , &btsBank_ ); - //tree_->SetBranchAddress("RecoEcalClusters",&recoClu_,&brecoClu_ ); - //tree_->SetBranchAddress("KalmanFullTracks",&Trk_,&bTrk_); tree_->SetBranchAddress("FinalStateParticles_KF",&Part_,&bPart_); tree_->SetBranchAddress("SiClusters",&Clusters_,&bClusters_); tree_->SetBranchAddress("EventHeader",&evH_,&bevH_); - /* - //Making the Hit Efficiency Tree - TTree *HitEff_ = new TTree("hitEff","hitEff"); - HitEff_->Branch("L1",&L1_,"L1/I"); - //HitEff_->SetBranchAddress("L1",&L1_,&bL1_); - */ - for (unsigned int i_reg = 0; i_reg < regionSelections_.size(); i_reg++) { std::string regname = AnaHelpers::getFileName(regionSelections_[i_reg],false); @@ -244,7 +195,6 @@ void SvtRawDataAnaProcessor::initialize(TTree* tree) { reg_histos_[regname] = std::make_shared(regname,mmapper_); reg_histos_[regname]->loadHistoConfig(histCfgFilename_); - //reg_histos_[regname]->doTrackComparisonPlots(false); reg_histos_[regname]->DefineHistos(); regions_.push_back(regname); @@ -261,82 +211,50 @@ void SvtRawDataAnaProcessor::initialize(TTree* tree) { bool SvtRawDataAnaProcessor::process(IEvent* ievent) { - //std::cout<<"hello5"<getEventTime(); - - //I AM DOING CLUSTER MATCHING HERE :) - std::cout<<"Here is the eventTime"<T<prescaled.Single_3_Top==1)or(tsBank_->prescaled.Single_3_Bot==1)))){return true;} //ONLY POSITRONS, MAY USE FEE's //ONCE I DETERMINE A CLUSTER WHICH IS IN LINE WITH TRIG, I CAN USE ANY CLUSTERS CLOSE IN TIME. - //std::cout<<"Trigger Time: "<singletrigs.at(0).T<Fill(); - } - return true; - }*/ + for(unsigned int i = 0; isize();i++){ Clusters_->at(i)->getLayer(); } for(unsigned int i = 0; i < svtHits_->size(); i++){ RawSvtHit * thisHit = svtHits_->at(i); - int getNum = thisHit->getFitN();//std::cout<<"I got here 10"<getFitN(); if(doClMatch){ bool Continue = true; for(int i = 0; isize();i++){ - //std::cout<<"Do I break here 3"<at(i)->getPDG()==22){continue;} - //std::cout<<"Do I break here 4"<at(i)->getCluster().getEnergy()<0){continue;} - //std::cout<<"Do I break here 5"<at(i)->getCluster().getTime()<=40)and(Part_->at(i)->getCluster().getTime()>=36))){continue;} - //std::cout<<"For each Tracker Hit I now print out Raw Hit Info: "<at(i)->getTrack().getSvtHits().GetEntries();j++){ //std::cout<<"Do I break here 6"<at(i)->getTrack().getSvtHits().At(j)); double TrackTime = Part_->at(i)->getTrack().getTrackTime(); - //std::cout<getTime()<getRawHits().GetEntries();k++){ RawSvtHit * rHit = (RawSvtHit*)(tHit->getRawHits().At(k)); - //if(rHit->getT0(0)==thisHit->getT0(0)){ - //STR=rHit->getStrip(); int mode=0; if((rHit->getT0(0)==thisHit->getT0(0))and(mode==0)){//or(mode==2))){ //This is the HIT ON TRACK Modes bool InCluster = false; int LAY = 0;//THE PURPOSE OF LAY IS TO COUNT THE NUMBER OF HITS PER LAYER - //std::cout<<"DID I GET HERE B4 CLUSTERS"<size(); Cl++){ - //std::cout<<"DO I GET HERE"<at(Cl)->getRawHits().GetEntries(); Clh++){ - //std::cout<<"DO I GET HERE 2"<at(Cl)->getRawHits().At(Clh)); if((cluHit->getLayer()==thisHit->getLayer())and(cluHit->getModule()==thisHit->getModule())){ LAY++; @@ -350,16 +268,13 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { otherTime = otherHit->getT0(0); } } - //if((mode==2)and((cluHit->getStrip()-thisHit->getStrip())*(cluHit->getStrip()-thisHit->getStrip())<=100)and(rHit->getLayer()==thisHit->getLayer())and(rHit->getModule()==thisHit->getModule())and((cluHit->getT0(0)-TrackTime)*(cluHit->getT0(0)-TrackTime)<=(thisHit->getT0(0)-TrackTime)*(thisHit->getT0(0)-TrackTime))){ - // MissHit==true; - //} } } if(InCluster){ Continue = false; } - }//std::cout<getLayer()<getT0(0)<=-30)and(not(rHit->getT0(0)==thisHit->getT0(0)))and(mode==1)){ //This is the HIT OFF TRACK Mode //You are looking at the really early time on track hits, and specifically at other hits in the same layer and module @@ -372,13 +287,9 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { bool InCluster = false; int LAY = 0;//THE PURPOSE OF LAY IS TO COUNT THE NUMBER OF HITS PER LAYER - //std::cout<<"DID I GET HERE B4 CLUSTERS"<size(); Cl++){ - //std::cout<<"DO I GET HERE"<at(Cl)->getRawHits().GetEntries(); Clh++){ - //std::cout<<"DO I GET HERE 2"<at(Cl)->getRawHits().At(Clh)); - //std::cout<getLayer()<getLayer()==thisHit->getLayer())and(cluHit->getModule()==thisHit->getModule())){ LAY++; } @@ -394,37 +305,15 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { } } } - - - //if(rHit->getT0(0)==thisHit->getT0(0)){ - //Continue=false; - //bool helper=true;//(Part_->at(i)->getTrack().getTrackerHitCount()>=12); - //helper = (helper)and(thisHit->getChiSq(0)<.9); - //helper=(helper)and(Part_->at(i)->getTrack().getChi2()<=8); - //if(helper){ - // Continue=false; - //} - //} - //std::cout<<"Raw Hit T0: "<getT0(0)<at(i)->getTrack().getSvtHits().At(j)->getRawHits().At(0).getT0()<getT0(J))-(thisHit->getT0((J+1)%2)); if(!(reg_selectors_[regions_[i_reg]]->passCutLt("TimeDiff_lt",TimeDiff*TimeDiff,weight))){continue;} } - //std::cout<<"Did I atleast make it here?"<passCutEq("getId_lt",J,weight))){continue;} if(!(reg_selectors_[regions_[i_reg]]->passCutEq("getId_gt",J,weight))){continue;} @@ -444,7 +332,6 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { if(!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_ft",(((thisHit->getT0(J))-TimeRef)*((thisHit->getT0(J))-TimeRef)<((thisHit->getT0((J+1)%getNum)-TimeRef)*(thisHit->getT0((J+1)%getNum)-TimeRef)+.00001)),weight))){continue;} - //std::cout<<"I Made it here"<passCutLt("doing_ct",(((thisHit->getT0(J))-TimeRef)*((thisHit->getT0(J))-TimeRef)>((thisHit->getT0((J+1)%getNum)-TimeRef)*(thisHit->getT0((J+1)%getNum)-TimeRef)+.00001)),weight))){continue;} }else{ @@ -452,24 +339,17 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { if(!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_ct",(((thisHit->getT0(J))-TimeRef)*((thisHit->getT0(J))-TimeRef)>((thisHit->getT0((J+1)%getNum)-TimeRef)*(thisHit->getT0((J+1)%getNum)-TimeRef)+.00001)),weight))){continue;} } } - //std::cout<<"I Made it here 2"<passCutLt("doing_ca",(((thisHit->getAmp(J))-AmpRef)*((thisHit->getAmp(J))-AmpRef)<((thisHit->getAmp((J+1)%getNum)-AmpRef)*(thisHit->getAmp((J+1)%getNum)-AmpRef)+.00001)),weight))){continue;} if(!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_fterr",(((thisHit->getT0err(J))-TimeRef)*((thisHit->getT0err(J))-TimeRef)<((thisHit->getT0err((J+1)%getNum)-TimeRef)*(thisHit->getT0err((J+1)%getNum)-TimeRef)+.00001)),weight))){continue;} if(!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_cterr",(((thisHit->getT0err(J))-0.0)*((thisHit->getT0err(J))-0.0)>((thisHit->getT0err((J+1)%getNum)-0.0)*(thisHit->getT0err((J+1)%getNum)-0.0)+.00001)),weight))){continue;} - - //if(!(std::abs((thisHit->getT0(J))-TimeRef)getT0((J+1)%2)-TimeRef))){continue;} - //if(!(reg_selectors_[regions_[i_reg]]->passCutEq("doing_ca",1.0,weight))){continue;}else{ - //if(!(std::abs((thisHit->getT0(J))-TimeRef)getT0((J+1)%2)-TimeRef))){continue;} + if(!(reg_selectors_[regions_[i_reg]]->passCutLt("amp_lt",thisHit->getAmp(0),weight))){continue;} if(!(reg_selectors_[regions_[i_reg]]->passCutGt("amp_gt",thisHit->getAmp(0),weight))){continue;} if(!(reg_selectors_[regions_[i_reg]]->passCutLt("time_lt",thisHit->getT0(0),weight))){continue;} if(!(reg_selectors_[regions_[i_reg]]->passCutGt("time_gt",thisHit->getT0(0),weight))){continue;} - //std::cout<<(float)(thisHit->getT0((J+1)%getNum))<passCutLt("Otime_lt",(float)(thisHit->getT0((J+1)%getNum)),weight))<passCutGt("Otime_gt",(float)(thisHit->getT0((J+1)%getNum)),weight))<passCutLt("Otime_lt",(float)(thisHit->getT0((J+1)%getNum)),weight))){continue;} if(!(reg_selectors_[regions_[i_reg]]->passCutGt("Otime_gt",(float)(thisHit->getT0((J+1)%getNum)),weight))){continue;} @@ -486,12 +366,8 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { } if(!(reg_selectors_[regions_[i_reg]]->passCutEq("first_max",adcs[0]-maxx,weight))){continue;} - //if(!(reg_selectors_[regions_[i_reg]]->passCutEq("time_phase",trigPhase,weight))){continue;} - bool helper = false; - //std::cout<<"hello"<getEventNumber(); - //std::cout<=2)){continue;} if((regions_[i_reg]=="CTFit")and((thisHit->getT0(J)<26.0)or(thisHit->getT0(J)>30.0))){continue;} sample(thisHit,regions_[i_reg],ievent,eventTime,N); @@ -512,41 +385,8 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { } } } - //std::cout<size();i++){ - //std::cout<<"Do I break here 3"<at(i)->getPDG()==22){continue;} - //std::cout<<"Do I break here 4"<at(i)->getCluster().getEnergy()<0){continue;} - //std::cout<<"Do I break here 5"<at(i)->getCluster().getTime()<=40)and(Part_->at(i)->getCluster().getTime()>=36))){continue;} - //std::cout<<"For each Tracker Hit I now print out Raw Hit Info: "<at(i)->getTrack().getTrackerHitCount()>12){ - deno = 0; - for(int j = 0; jat(i)->getTrack().getSvtHits().GetEntries();j++){ - TrackerHit * tHit = (TrackerHit*)(Part_->at(i)->getTrack().getSvtHits().At(j)); - for(int k = 0;kgetRawHits().GetEntries();k++){ - RawSvtHit * rHit = (RawSvtHit*)(tHit->getRawHits().At(k)); - if((rHit->getLayer()==L)){ - deno = 1; - //I DID THE PROBE - } - } - } - } - } - return deno; -} -*/ - + } void SvtRawDataAnaProcessor::sample(RawSvtHit* thisHit,std::string word, IEvent* ievent,long T,int N){ auto mod = std::to_string(thisHit->getModule()); @@ -563,10 +403,7 @@ int SvtRawDataAnaProcessor::hitEff(IEvent* ievent, int L){ if((feb>=2)and(word=="OneFit")){return;} if((feb<2)and(word=="CTFit")){return;} if(thisHit->getChiSq(0)<.85){return;} - - - - //std::cout<<"Feb "<getStrip()][0]<<" ,Baseline Feb>1: "<getStrip()][0]<<" More Baselines "<getStrip()][0]<<" ,Baseline Feb>1: "<getStrip()][0]<getStrip()); @@ -574,16 +411,11 @@ int SvtRawDataAnaProcessor::hitEff(IEvent* ievent, int L){ BigCount+=4096; BigCount+=(feb-2)*2560+hyb*640+(int)(thisHit->getStrip()); } - //std::cout<<"READ HERE "<getStrip()<<" "<getStrip()][0]<getADCs(); - //std::cout<getT0(0)),T),-1*rETime(-(thisHit->getT0(1)),T)}; fitfunc->FixParameter(0,TimeShift[0]); @@ -597,7 +429,6 @@ int SvtRawDataAnaProcessor::hitEff(IEvent* ievent, int L){ fitfunc->FixParameter(1,times2_[feb-2][hyb][(int)thisHit->getStrip()][1]); fitfunc->FixParameter(2,times2_[feb-2][hyb][(int)thisHit->getStrip()][2]); fitfunc->FixParameter(4,baseErr2_[feb-2][hyb][(int)thisHit->getStrip()][1]); - //baseline->FixParameter(0,baseErr2_[feb-2][hyb][(int)thisHit->getStrip()][1]); } if(thisHit->getFitN()==2){ fitfunc2->FixParameter(0,TimeShift[1]); @@ -634,40 +465,23 @@ int SvtRawDataAnaProcessor::hitEff(IEvent* ievent, int L){ } } - //for(int P=0;P<2;P++){for(int PP=0;PP<4;PP++){ std::cout<<"baseline: "<getStrip()][0]<getStrip()][0]<<" "<getStrip()][0]<vRange(0.0,3000.0,150.0,6000.0); readout[K]++; - //auto gr = new TGraph(); - //auto gr2 = new TGraph(); - std::string helper1="Feb: "+std::to_string(feb)+",Hyb: "+std::to_string(hyb)+",ch: "+std::to_string((int)thisHit->getStrip())+", chi_sqr value: "+std::to_string((float)thisHit->getChiSq(0)); const char *thing1 = helper1.data(); - //gr2->SetPoint(0,0.,3000.);gr2->SetPoint(1,0.,6000.);gr2->SetPoint(2,150.0,6000.); - //gPad->DrawFrame(0.0,3000.0,150.0,6000.0); TCanvas *c1 = new TCanvas("c"); c1->DrawFrame(0.0,3000.0,150.0,7000.0); c1->SetTitle(thing1); - //auto gr = new TGraphErrors(); - //gr->SetName("ADCs"); float times[12]; float points[12]; float errors[12]; float zeroes[12]; for(int i=0;i<6;i++){ - //std::cout<getStrip()][i]; errors[i]=baseErr1_[feb][hyb][(int)thisHit->getStrip()][i+6]; }else{ - //std::cout<<(float(i))*24.0-27.0<<" "<getStrip()][i]; errors[i]=baseErr2_[feb-2][hyb][(int)thisHit->getStrip()][i+6]; @@ -681,13 +495,8 @@ int SvtRawDataAnaProcessor::hitEff(IEvent* ievent, int L){ gr->GetXaxis()->SetLimits(-10.0,130.); gr->GetHistogram()->SetMaximum(2000.); gr->GetHistogram()->SetMinimum(-500.); - //gr2->Draw(""); gr->Draw("AL*"); - //TF1* helper1 = (TF1*)fitfunc->Clone("ff"); - - //baseline->SetLineColor(kBlue); - //baseline->Draw("same"); - + fitfunc->Draw("same"); if(thisHit->getFitN()==2){ fitfunc2->SetLineColor(kGreen); @@ -696,14 +505,7 @@ int SvtRawDataAnaProcessor::hitEff(IEvent* ievent, int L){ fitfunc3->SetTitle(thing1); fitfunc3->Draw("same"); - - //TF1 *add = new TF1("ff+gg-base",); - //TF1* fitfunc3 = new TF1("ll","ff+gg+base"); - //TF1* h = new TF1("hh","ff+gg"); - //add->Draw("same"); - //auto ADD = new TF1(); } - //gr->Draw("same"); auto legend = new TLegend(0.1,0.7,.48,.9); legend->AddEntry("gr","ADC counts"); legend->AddEntry("base","Offline Baselines"); @@ -716,22 +518,6 @@ int SvtRawDataAnaProcessor::hitEff(IEvent* ievent, int L){ std::string helper2=word+std::to_string(readout[K]-1)+".png"; const char *thing2 = helper2.data(); c1->SaveAs(thing2); - //gPad->Clear(); - - - //if(helper2=="OneFit8.png"){ - //std::cout<getStrip()<getStrip()][0]<<" "<getStrip()][1]<<" "<getStrip()][2]<<" "<getStrip()][3]<<" "<getStrip()][4]<<" "<getStrip()][5]<getAmp(0)<<" "<getT0(0)<<" "<getChiSq(0)<cd(); - /*TDirectory* hitdir{nullptr}; - hitdir = outF_->mkdir("HitEfficiency"); - hitdir->cd(); - HitEff_->Write(); */ for(reg_it it = reg_histos_.begin(); it!=reg_histos_.end(); ++it){ std::string dirName = it->first; (it->second)->saveHistos(outF_,dirName); outF_->cd(dirName.c_str()); - //reg_selectors_[it->first]->getCutFlowHisto()->Scale(.5); - //reg_selectors_[it->first]->getCutFlowHisto()->Write(); } outF_->Close(); From 587d0e8ff872b7e3ddf71dfae698db24f8792263 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 12:33:12 -0800 Subject: [PATCH 18/70] Update SvtRawDataAnaProcessor.cxx --- processors/src/SvtRawDataAnaProcessor.cxx | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/processors/src/SvtRawDataAnaProcessor.cxx b/processors/src/SvtRawDataAnaProcessor.cxx index a97f4f02a..297b9a593 100644 --- a/processors/src/SvtRawDataAnaProcessor.cxx +++ b/processors/src/SvtRawDataAnaProcessor.cxx @@ -217,9 +217,9 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { long eventTime = evH_->getEventTime(); bool doClMatch = true; - int STR = -10000; - int HITC = 0; - int HITL = 0; + int stripID = -10000; + int hitc = 0; + int hitl = 0; float otherTime = 69420.0; @@ -261,8 +261,8 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { } if((cluHit->getT0(0)==thisHit->getT0(0))){//and(not(Clusters_->at(Cl)->getID()==tHit->getID()))){ InCluster = true; - HITC=Clusters_->at(Cl)->getRawHits().GetEntries(); - HITL=LAY; + hitc=Clusters_->at(Cl)->getRawHits().GetEntries(); + hitl=LAY; if(Clusters_->at(Cl)->getRawHits().GetEntries()==2){ RawSvtHit * otherHit = (RawSvtHit*)(Clusters_->at(Cl)->getRawHits().At((Clh+1)%2)); otherTime = otherHit->getT0(0); @@ -281,10 +281,9 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { //to see if you have evidence of a misplaced hit. if((rHit->getLayer()==thisHit->getLayer())and(rHit->getModule()==thisHit->getModule())){ - STR=rHit->getStrip(); + stripID=rHit->getStrip(); //THIS CONDITIONS ON IT BEING IN CLUSTERS - bool InCluster = false; int LAY = 0;//THE PURPOSE OF LAY IS TO COUNT THE NUMBER OF HITS PER LAYER for(int Cl = 0; Cl < Clusters_->size(); Cl++){ @@ -295,8 +294,8 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { } if((cluHit->getT0(0)==thisHit->getT0(0))and(not(Clusters_->at(Cl)->getID()==tHit->getID()))){ InCluster = true; - HITC=Clusters_->at(Cl)->getRawHits().GetEntries(); - HITL=LAY; + hitc=Clusters_->at(Cl)->getRawHits().GetEntries(); + hitl=LAY; } } } @@ -381,7 +380,7 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { sample(thisHit,regions_[i_reg],ievent,eventTime,N); } - reg_histos_[regions_[i_reg]]->FillHistograms(thisHit,weight,J,i,TimeDiff,AmpDiff,STR,HITC,HITL,otherTime); + reg_histos_[regions_[i_reg]]->FillHistograms(thisHit,weight,J,i,TimeDiff,AmpDiff,stripID,hitc,hitl,otherTime); } } } From 3803627765f4f7cb7bd4b8ca783bce3c661f2a8f Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 12:47:41 -0800 Subject: [PATCH 19/70] Update ClusterAnaProcessor.cxx --- processors/src/ClusterAnaProcessor.cxx | 56 +++++++++++++++++++++----- 1 file changed, 46 insertions(+), 10 deletions(-) diff --git a/processors/src/ClusterAnaProcessor.cxx b/processors/src/ClusterAnaProcessor.cxx index 8cafbf4f2..5c7f5aefc 100644 --- a/processors/src/ClusterAnaProcessor.cxx +++ b/processors/src/ClusterAnaProcessor.cxx @@ -30,7 +30,6 @@ void ClusterAnaProcessor::configure(const ParameterSet& parameters) { } - void ClusterAnaProcessor::initialize(TTree* tree) { fillDeads(); tree_= tree; @@ -108,19 +107,29 @@ void ClusterAnaProcessor::initialize(TTree* tree) { } } +/** + * + *THIS METHOD FILLS SEVERAL HISTOGRAMS FOR EACH EVENT DIRECTED AT EVALUATING CLUSTERING PERFORMANCE. FOR OUR TRACKING + *VARIABLES WE PLOT Z0 VS THE NUMBER OF SHARED HITS WITH AND WITHOUT A CLUSTER CUT (WE EXPECT A GOOD RECONSTRUCTION TO HAVE + *HAVE A LOW NUMBER OF SHARED CLUSTERS, ESPECIALLY AROUND THE Z0 VERTEX AND THAT THIS WOULD FURTHER IMPROVE WITH HIGH P TRACKS) + * + * + *TO FURTHER CHARACTERIZE THE CLUSTERS WE CAPTURE BASIC INFORMATION: CLUSTER AMPLITUDE, TIME, CHARGE, and STRIP CLUSTER POSITION + *AND DISTANCES. WE DO THIS FOR SHARED AND UNSHARED CLUSTERS. WE PERFORM THIS FILLING ALSO BASED ON A CLUSTER BEING NTD, MEANING + *NEXT TO DEAD. + * + * */ + bool ClusterAnaProcessor::process(IEvent* ievent) { if(doingTracks_){ for(int i = 0;isize();i++){ Track* track = tracks_->at(i); - //bool general = ((layer_==-1)||(module_==-1)); - //if(((LAYER==layer_)&&(MODULE==module_))||(general)){ - if(track->getTrackTime()*track->getTrackTime()<100.0){ - Z0VNShare2Hist_->Fill(track->getZ0Err(),track->getNShared()); - if(track->getP()Fill(track->getZ0Err(),track->getNShared()); - } + if(track->getTrackTime()*track->getTrackTime()<100.0){ + Z0VNShare2Hist_->Fill(track->getZ0Err(),track->getNShared()); + if(track->getP()Fill(track->getZ0Err(),track->getNShared()); } - //} + } } } for(int i = 0; i < Clusters_->size(); i++){ @@ -242,6 +251,12 @@ bool ClusterAnaProcessor::process(IEvent* ievent) { return true; } +/** + * + *THIS METHOD FILLS THE COLLECTION OF DEAD CHANNEL IDS GIVEN AN INPUT FILENAME. REQUIRED FOR NTD PLOTS + * + * */ + void ClusterAnaProcessor::fillDeads(){ for(int i = 0;i<24576;i++){ Deads_[i]=0.0; @@ -258,6 +273,12 @@ void ClusterAnaProcessor::fillDeads(){ return; } +/** + * + *THIS METHOD GITS THE STRIP COUNT OUT OF ROUGHLY 25000 GIVEN THE FEB AND HYBRID IDS AND THE STRIP NO WRT THESE IDS + * + * */ + int ClusterAnaProcessor::GetStrip(int feb,int hyb,int strip){ int BigCount = 0; if(feb<=1){ @@ -269,6 +290,15 @@ int ClusterAnaProcessor::GetStrip(int feb,int hyb,int strip){ return BigCount; } +/** + * + *THE REMAINING METHODS (UP TO TRACKPLOT) ALL PLOT STANDARD HISTOGRAMS DESCRIBED IN THE DESCRIPTION TO THE PROCESS METHOD. + *THEY INCLUDE STANDARD FUNCTION CALLS YOU WOULD EXPECT IN A ROOT MACRO AND AFFORD SOME MORE CONTROL THAN A HISTOMANAGER AND + *REGION SELECTOR COMBO. + *FEASIBLE FOR A LIMITED NUMBER OF COLLECTION CUTS. + * + * */ + void ClusterAnaProcessor::PlotClusterLayers(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); @@ -355,7 +385,7 @@ void ClusterAnaProcessor::PlotClusterCharges(){ c1->Clear(); return; } -//NTD REFERS TO NEXT TO DEAD CHANNELS + void ClusterAnaProcessor::PlotClusterLayersNTD(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); @@ -618,6 +648,12 @@ void ClusterAnaProcessor::TrackPlot(){ return; } +/** + * + *THE FINALIZE METHOD CALLS ALL THE PLOTTING MACROS ABOVE. THEY ARE CREATED INTO PNGS INTO THE REPOSITORY THE PROCESSOR IS CALLED IN. + * + * */ + void ClusterAnaProcessor::finalize() { PlotClusterLayers(); PlotClusterLayersNTD(); From 6cc3479b7a0f284609f7e50abd564ec551d865e1 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 13:00:28 -0800 Subject: [PATCH 20/70] Update ClusterCompareAnaProcessor.cxx --- processors/src/ClusterCompareAnaProcessor.cxx | 44 +++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/processors/src/ClusterCompareAnaProcessor.cxx b/processors/src/ClusterCompareAnaProcessor.cxx index 297669906..6628cc755 100644 --- a/processors/src/ClusterCompareAnaProcessor.cxx +++ b/processors/src/ClusterCompareAnaProcessor.cxx @@ -164,6 +164,23 @@ void ClusterCompareAnaProcessor::initialize(TTree* tree) { } } +/** + * + *THIS METHOD FILLS SEVERAL HISTOGRAMS FOR EACH EVENT DIRECTED AT EVALUATING CLUSTERING PERFORMANCE. FOR OUR TRACKING + *VARIABLES WE PLOT Z0 VS THE NUMBER OF SHARED HITS WITH AND WITHOUT A CLUSTER CUT (WE EXPECT A GOOD RECONSTRUCTION TO HAVE + *HAVE A LOW NUMBER OF SHARED CLUSTERS, ESPECIALLY AROUND THE Z0 VERTEX AND THAT THIS WOULD FURTHER IMPROVE WITH HIGH P TRACKS) + * + * + *TO FURTHER CHARACTERIZE THE CLUSTERS WE CAPTURE BASIC INFORMATION: CLUSTER AMPLITUDE, TIME, CHARGE, and STRIP CLUSTER POSITION + *AND DISTANCES. WE DO THIS FOR SHARED AND UNSHARED CLUSTERS. WE LARGELY IGNORE NTD, OR NEXT TO DEAD, ANALYSIS IN THIS PROCESSOR. + * + *THIS PROCESSOR IS UNDENIABLY EXTREMELY SIMILAR TO CLUSTERANAPROCESSOR, HAVING BEEN ITS OFFSPRING. THE MAIN DISTINCTION IS THAT + *THIS PROCESSOR IMPLEMENTS AN IDENTITY TRACKER (ident_) WHICH, ATM, IS IMPLEMENTED TO DETECT WHETHER AN EVENT IS IN TYPE 1 OR TYPE2 + *ALONG WITH A SHORT MACRO WHICH ASSOCIATES TO DIFFERENTLY RECONSTRUCTED ROOT FILES A IDENTIFICATION MONICER, THIS ALLOWS FOR QUICK + *DIRECT COMPARISON OF TWO MEANS OF RECONSTRUCTION. + * + * */ + bool ClusterCompareAnaProcessor::process(IEvent* ievent) { if(doingTracks_){ for(int i = 0;isize();i++){ @@ -309,6 +326,12 @@ bool ClusterCompareAnaProcessor::process(IEvent* ievent) { return true; } +/** + * + *THIS METHOD FILLS THE COLLECTION OF DEAD CHANNEL IDS GIVEN AN INPUT FILENAME. REQUIRED FOR NTD PLOTS, BUT LARGELY DISUSED IN THIS PROCESSOR AS OF YET. + * + * */ + void ClusterCompareAnaProcessor::fillDeads(){ for(int i = 0;i<24576;i++){ Deads_[i]=0.0; @@ -325,6 +348,12 @@ void ClusterCompareAnaProcessor::fillDeads(){ return; } +/** + * + *THIS METHOD GITS THE STRIP COUNT OUT OF ROUGHLY 25000 GIVEN THE FEB AND HYBRID IDS AND THE STRIP NO WRT THESE IDS + * + * */ + int ClusterCompareAnaProcessor::GetStrip(int feb,int hyb,int strip){ int BigCount = 0; if(feb<=1){ @@ -336,6 +365,15 @@ int ClusterCompareAnaProcessor::GetStrip(int feb,int hyb,int strip){ return BigCount; } +/** + * + *THE REMAINING METHODS (UP TO TRACKPLOT) ALL PLOT STANDARD HISTOGRAMS DESCRIBED IN THE DESCRIPTION TO THE PROCESS METHOD. + *THEY INCLUDE STANDARD FUNCTION CALLS YOU WOULD EXPECT IN A ROOT MACRO AND AFFORD SOME MORE CONTROL THAN A HISTOMANAGER AND + *REGION SELECTOR COMBO. + *FEASIBLE FOR A LIMITED NUMBER OF COLLECTION CUTS. + * + * */ + void ClusterCompareAnaProcessor::PlotClusterLayers(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); @@ -668,6 +706,12 @@ void ClusterCompareAnaProcessor::TrackTransverseMomenta(){ return; } +/** + * + *THE FINALIZE METHOD CALLS ALL THE PLOTTING MACROS ABOVE. THEY ARE CREATED INTO PNGS INTO THE REPOSITORY THE PROCESSOR IS CALLED IN. + * + * */ + void ClusterCompareAnaProcessor::finalize() { PlotClusterLayers(); PlotClusterCharges(); From a0ebd656c8b2c651cfe99c3ded19dd4b5b22ed85 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 13:02:27 -0800 Subject: [PATCH 21/70] Update ClusterAnaProcessor.cxx --- processors/src/ClusterAnaProcessor.cxx | 2 ++ 1 file changed, 2 insertions(+) diff --git a/processors/src/ClusterAnaProcessor.cxx b/processors/src/ClusterAnaProcessor.cxx index 5c7f5aefc..1e2b47b7a 100644 --- a/processors/src/ClusterAnaProcessor.cxx +++ b/processors/src/ClusterAnaProcessor.cxx @@ -1,6 +1,8 @@ /** * @file ClusterAnaProcessor.cxx * @brief AnaProcessor used fill histograms to study cluster reconstruction algorithms and dead channels. + * Does not feature a region selector or histomanager (i.e. no configurable json files), rather + * for the limited featured plots allows for more specific manipulation and control. * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory */ #include "ClusterAnaProcessor.h" From a19574792030b3e0ffdf3b901b4d5a3e4de19dc1 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 13:02:57 -0800 Subject: [PATCH 22/70] Update ClusterCompareAnaProcessor.cxx --- processors/src/ClusterCompareAnaProcessor.cxx | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/processors/src/ClusterCompareAnaProcessor.cxx b/processors/src/ClusterCompareAnaProcessor.cxx index 6628cc755..1c12d5a8a 100644 --- a/processors/src/ClusterCompareAnaProcessor.cxx +++ b/processors/src/ClusterCompareAnaProcessor.cxx @@ -1,6 +1,8 @@ /** * @file ClusterCompareAnaProcessor.cxx - * @brief AnaProcessor used to compare two means of reconstruction directly. + * @brief AnaProcessor used to compare two means of reconstruction directly. Fills histograms to study cluster reconstruction algorithms and dead channels. + * Does not feature a region selector or histomanager (i.e. no configurable json files), rather + * for the limited featured plots allows for more specific manipulation and control. * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory */ #include "ClusterCompareAnaProcessor.h" From 99144ffe14e8d94a7e6d8fc4aad7c8a6d8198d5b Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 13:08:21 -0800 Subject: [PATCH 23/70] Add files via upload --- scripts/AddIdentity.C | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 scripts/AddIdentity.C diff --git a/scripts/AddIdentity.C b/scripts/AddIdentity.C new file mode 100644 index 000000000..bab2d42fe --- /dev/null +++ b/scripts/AddIdentity.C @@ -0,0 +1,13 @@ +void AddIdentity(){ + TFile *f = new TFile("rootcopy0.root","update"); + TTree *tree = (TTree *)(f->Get("HPS_Event")); + Float_t helper = 1.0; + auto my_new_branch = tree->Branch("Identifier",&helper,"Identifier/F"); + for (Long64_t entry = 0 ; entry < tree->GetEntries() ; entry++ ) { + //tree->GetEntry(); + /* something to compute my_local_variable */ + std::cout<Fill(); + } + tree->Write("",TObject::kOverwrite); +} From 0b1ee7b69fe63b49bb4d63dd5e29a236e934177d Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 13:11:07 -0800 Subject: [PATCH 24/70] Update AddIdentity.C --- scripts/AddIdentity.C | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/scripts/AddIdentity.C b/scripts/AddIdentity.C index bab2d42fe..faae5b898 100644 --- a/scripts/AddIdentity.C +++ b/scripts/AddIdentity.C @@ -1,3 +1,8 @@ +/* +* SIMPLE ROOT MACRO. ASSOCIATES TO EACH EVENT IN A ROOT FILE AN IDENTIFIER WHICH +* CAN BE USED POST HADD TO PROCESS A SINGLE FILE WITH MULTIPLE RECONSTRUCTION ALGORITHMS +* USED IN A SINGLE PROCESSOR. +*/ void AddIdentity(){ TFile *f = new TFile("rootcopy0.root","update"); TTree *tree = (TTree *)(f->Get("HPS_Event")); From e30a221983da51445d4b2c379b40940e39a1008c Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 13:13:02 -0800 Subject: [PATCH 25/70] Update clusterCompareAna.py --- processors/config/clusterCompareAna.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/processors/config/clusterCompareAna.py b/processors/config/clusterCompareAna.py index 1e010c679..d4afb424d 100644 --- a/processors/config/clusterCompareAna.py +++ b/processors/config/clusterCompareAna.py @@ -8,7 +8,7 @@ base.parser.add_argument("-M", "--module", type=int, dest="module", help="Module Under Investigation", metavar="module",default=-1) base.parser.add_argument("-MC", "--MC", type=int, dest="isMC", - help="IS IT MC", metavar="module",default=0) + help="Is the file used generated from Monte Carlo", metavar="module",default=0) base.parser.add_argument("-doT", "--doT", type=int, dest="doTrack", help="we plot tracking related cluster performance metrics", metavar="doTrack",default=0) base.parser.add_argument("-cut", "--cut", type=float, dest="cut", From 4192a6388403d82c5adfe403d39362c839cb5f5e Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Fri, 9 Feb 2024 13:13:25 -0800 Subject: [PATCH 26/70] Update clusterAna.py --- processors/config/clusterAna.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/processors/config/clusterAna.py b/processors/config/clusterAna.py index 53d5afcb9..9c372b89c 100644 --- a/processors/config/clusterAna.py +++ b/processors/config/clusterAna.py @@ -8,7 +8,7 @@ base.parser.add_argument("-M", "--module", type=int, dest="module", help="Module Under Investigation", metavar="module",default=-1) base.parser.add_argument("-MC", "--MC", type=int, dest="isMC", - help="IS IT MC", metavar="module",default=0) + help="Is the file used generated from Monte Carlo", metavar="module",default=0) base.parser.add_argument("-doT", "--doT", type=int, dest="doTrack", help="We plot the tracking based cluster performance metrics", metavar="doTrack",default=0) base.parser.add_argument("-cut", "--cut", type=float, dest="cut", From e8235b2c5a1baac850de859e64b3ead8c5a8694e Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 11:57:55 -0800 Subject: [PATCH 27/70] Update ClusterAnaProcessor.cxx --- processors/src/ClusterAnaProcessor.cxx | 28 ++++++++++++-------------- 1 file changed, 13 insertions(+), 15 deletions(-) diff --git a/processors/src/ClusterAnaProcessor.cxx b/processors/src/ClusterAnaProcessor.cxx index 1e2b47b7a..7cd882205 100644 --- a/processors/src/ClusterAnaProcessor.cxx +++ b/processors/src/ClusterAnaProcessor.cxx @@ -136,13 +136,13 @@ bool ClusterAnaProcessor::process(IEvent* ievent) { } for(int i = 0; i < Clusters_->size(); i++){ TrackerHit * clu = Clusters_->at(i); - Int_t LAYER = -1; - Int_t MODULE = -1; + Int_t layc = -1; + Int_t modc = -1; RawSvtHit * seed = (RawSvtHit*)(clu->getRawHits().At(0)); - LAYER=clu->getLayer(); - MODULE=seed->getModule(); + layc=clu->getLayer(); + modc=seed->getModule(); if(doingTracks_){ bool isShared = false;int increment = 0; @@ -160,7 +160,7 @@ bool ClusterAnaProcessor::process(IEvent* ievent) { } if(increment>0){ bool general = ((layer_==-1)||(module_==-1)); - if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + if(((layc==layer_)&&(modc==module_))||(general)){ if(isShared){ SharedAmplitudes_->Fill(clu->getCharge()); SharedTimes_->Fill(clu->getTime()); @@ -186,7 +186,7 @@ bool ClusterAnaProcessor::process(IEvent* ievent) { } - std::string input = "ly"+std::to_string(LAYER+1)+"_m"+std::to_string(MODULE); + std::string input = "ly"+std::to_string(layc+1)+"_m"+std::to_string(modc); std::string helper = mmapper_->getHwFromSw(input); int feb=std::stoi(helper.substr(1,1)); @@ -201,16 +201,16 @@ bool ClusterAnaProcessor::process(IEvent* ievent) { NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelR)]==1); } bool general = ((layer_==-1)||(module_==-1)); - if(((LAYER==layer_)&&(MODULE==module_))||(general)){ - //NOW IS THE PART WHERE I FILL THE CLUSTER DISTANCE HISTOGRAM + if(((layc==layer_)&&(modc==module_))||(general)){ + //Now is the part where I fill the cluster distance histogram. float Dist=69420; for(int p = 0; p < Clusters_->size(); p++){ if(p==i){continue;} TrackerHit * clu2 = Clusters_->at(p); RawSvtHit * seed2 = (RawSvtHit*)(clu2->getRawHits().At(0)); - float LAYER2=clu->getLayer(); - float MODULE2=seed->getModule(); - if((not(LAYER2==LAYER))or(not(MODULE2==MODULE))){continue;} + float layc2=clu->getLayer(); + float modc2=seed->getModule(); + if((not(layc2==layc))or(not(modc2==modc))){continue;} float dist = ((float)(seed2->getStrip()))-seedStrip; if(dist<0){dist*=-1.0;} if(distFill(Dist); if(NTD){ClusDistancesNTD_->Fill(Dist);} } - //std::cout<<"HELLO"<Fill(nLayers); charges_->Fill(ncharges); positions_->Fill(clu->getLayer()); @@ -618,8 +617,7 @@ void ClusterAnaProcessor::TrackPlot(){ c1->SaveAs("Z0VSharedProfile.png"); c1->Clear(); - //NOW I DO THE CHARGE DISTRIBUTION FOR SHARED AND UNSHARED HITS OVERLAYED - SharedAmplitudes_->SetTitle("The Charge of Clusters Shared Between Tracks"); + //Now I do the charge distribution for shared and unshared hits overlayed. legend = new TLegend(0.3,0.8,.68,.9); SharedAmplitudes_->SetLineColor(kRed); SharedAmplitudes_->SetLineWidth(2.0); @@ -633,7 +631,7 @@ void ClusterAnaProcessor::TrackPlot(){ c1->SaveAs("SharedVUnSharedChargeDist.png"); c1->Clear(); - //NOW I DO THE TIME DISTRIBUTION FOR SHARED AND UNSHARED HITS OVERLAYED + //Now I do the time distribution for shared and unshared hits overlayed. SharedTimes_->SetTitle("The Time of Clusters Shared Between Tracks"); legend = new TLegend(0.3,0.8,.68,.9); SharedTimes_->SetLineColor(kRed); From d2a0858ee58dfa94f9c34ef6ff5c59109093cf3c Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 13:01:04 -0800 Subject: [PATCH 28/70] Update ClusterCompareAnaProcessor.cxx --- processors/src/ClusterCompareAnaProcessor.cxx | 1 - 1 file changed, 1 deletion(-) diff --git a/processors/src/ClusterCompareAnaProcessor.cxx b/processors/src/ClusterCompareAnaProcessor.cxx index 1c12d5a8a..cd2bf67b2 100644 --- a/processors/src/ClusterCompareAnaProcessor.cxx +++ b/processors/src/ClusterCompareAnaProcessor.cxx @@ -11,7 +11,6 @@ ClusterCompareAnaProcessor::ClusterCompareAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ mmapper_ = new ModuleMapper(2021); } -//TODO CHECK THIS DESTRUCTOR ClusterCompareAnaProcessor::~ClusterCompareAnaProcessor(){} void ClusterCompareAnaProcessor::configure(const ParameterSet& parameters) { From 25176f216de5db0d01a6e9fd6278cf6dfc743133 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 13:10:18 -0800 Subject: [PATCH 29/70] Update ClusterCompareAnaProcessor.cxx --- processors/src/ClusterCompareAnaProcessor.cxx | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/processors/src/ClusterCompareAnaProcessor.cxx b/processors/src/ClusterCompareAnaProcessor.cxx index cd2bf67b2..bbdd12260 100644 --- a/processors/src/ClusterCompareAnaProcessor.cxx +++ b/processors/src/ClusterCompareAnaProcessor.cxx @@ -214,13 +214,13 @@ bool ClusterCompareAnaProcessor::process(IEvent* ievent) { } for(int i = 0; i < Clusters_->size(); i++){ TrackerHit * clu = Clusters_->at(i); - Int_t LAYER = -1; - Int_t MODULE = -1; + Int_t layc = -1; + Int_t modc = -1; RawSvtHit * seed = (RawSvtHit*)(clu->getRawHits().At(0)); - LAYER=clu->getLayer(); - MODULE=seed->getModule(); + layc=clu->getLayer(); + modc=seed->getModule(); if(doingTracks_){ bool isShared = false;int increment = 0; @@ -238,7 +238,7 @@ bool ClusterCompareAnaProcessor::process(IEvent* ievent) { } if(increment>0){ bool general = ((layer_==-1)||(module_==-1)); - if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + if(((layc==layer_)&&(modc==module_))||(general)){ if(isShared){ if(ident_<1.5){SharedAmplitudes1_->Fill(clu->getCharge());}else{SharedAmplitudes2_->Fill(clu->getCharge());} if(ident_<1.5){SharedTimes1_->Fill(clu->getTime());}else{SharedTimes2_->Fill(clu->getTime());} @@ -262,7 +262,7 @@ bool ClusterCompareAnaProcessor::process(IEvent* ievent) { onTrk = true; } } - std::string input = "ly"+std::to_string(LAYER+1)+"_m"+std::to_string(MODULE); + std::string input = "ly"+std::to_string(layc+1)+"_m"+std::to_string(modc); std::string helper = mmapper_->getHwFromSw(input); int feb=std::stoi(helper.substr(1,1)); int hyb=std::stoi(helper.substr(3,1)); @@ -276,16 +276,16 @@ bool ClusterCompareAnaProcessor::process(IEvent* ievent) { NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelR)]==1); } bool general = ((layer_==-1)||(module_==-1)); - if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + if(((layc==layer_)&&(modc==module_))||(general)){ //NOW IS THE PART WHERE I FILL THE CLUSTER DISTANCE HISTOGRAM float Dist=69420; for(int p = 0; p < Clusters_->size(); p++){ if(p==i){continue;} TrackerHit * clu2 = Clusters_->at(p); RawSvtHit * seed2 = (RawSvtHit*)(clu2->getRawHits().At(0)); - float LAYER2=clu->getLayer(); - float MODULE2=seed->getModule(); - if((not(LAYER2==LAYER))or(not(MODULE2==MODULE))){continue;} + float layc2=clu->getLayer(); + float modc2=seed->getModule(); + if((not(layc2==layc))or(not(modc2==modc))){continue;} float dist = ((float)(seed2->getStrip()))-seedStrip; if(dist<0){dist*=-1.0;} if(dist Date: Mon, 12 Feb 2024 13:14:24 -0800 Subject: [PATCH 30/70] Update SvtRawDataAnaProcessor.cxx --- processors/src/SvtRawDataAnaProcessor.cxx | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/processors/src/SvtRawDataAnaProcessor.cxx b/processors/src/SvtRawDataAnaProcessor.cxx index 297b9a593..4ccf214b5 100644 --- a/processors/src/SvtRawDataAnaProcessor.cxx +++ b/processors/src/SvtRawDataAnaProcessor.cxx @@ -252,17 +252,17 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { if((rHit->getT0(0)==thisHit->getT0(0))and(mode==0)){//or(mode==2))){ //This is the HIT ON TRACK Modes bool InCluster = false; - int LAY = 0;//THE PURPOSE OF LAY IS TO COUNT THE NUMBER OF HITS PER LAYER + int layc = 0;//THE PURPOSE OF layc IS TO COUNT THE NUMBER OF HITS PER LAYER for(int Cl = 0; Cl < Clusters_->size(); Cl++){ for(int Clh = 0; Clh < Clusters_->at(Cl)->getRawHits().GetEntries(); Clh++){ RawSvtHit * cluHit = (RawSvtHit*)(Clusters_->at(Cl)->getRawHits().At(Clh)); if((cluHit->getLayer()==thisHit->getLayer())and(cluHit->getModule()==thisHit->getModule())){ - LAY++; + layc++; } if((cluHit->getT0(0)==thisHit->getT0(0))){//and(not(Clusters_->at(Cl)->getID()==tHit->getID()))){ InCluster = true; hitc=Clusters_->at(Cl)->getRawHits().GetEntries(); - hitl=LAY; + hitl=layc; if(Clusters_->at(Cl)->getRawHits().GetEntries()==2){ RawSvtHit * otherHit = (RawSvtHit*)(Clusters_->at(Cl)->getRawHits().At((Clh+1)%2)); otherTime = otherHit->getT0(0); @@ -282,20 +282,20 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { if((rHit->getLayer()==thisHit->getLayer())and(rHit->getModule()==thisHit->getModule())){ stripID=rHit->getStrip(); - //THIS CONDITIONS ON IT BEING IN CLUSTERS + //This is conditioned on it being in clusters. bool InCluster = false; - int LAY = 0;//THE PURPOSE OF LAY IS TO COUNT THE NUMBER OF HITS PER LAYER + int layc = 0;//THE PURPOSE OF layc IS TO COUNT THE NUMBER OF HITS PER LAYER for(int Cl = 0; Cl < Clusters_->size(); Cl++){ for(int Clh = 0; Clh < Clusters_->at(Cl)->getRawHits().GetEntries(); Clh++){ RawSvtHit * cluHit = (RawSvtHit*)(Clusters_->at(Cl)->getRawHits().At(Clh)); if((cluHit->getLayer()==thisHit->getLayer())and(cluHit->getModule()==thisHit->getModule())){ - LAY++; + layc++; } if((cluHit->getT0(0)==thisHit->getT0(0))and(not(Clusters_->at(Cl)->getID()==tHit->getID()))){ InCluster = true; hitc=Clusters_->at(Cl)->getRawHits().GetEntries(); - hitl=LAY; + hitl=layc; } } } From 4d687fad4f556f4e2399c39e6301f0939d0faf9d Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 13:20:12 -0800 Subject: [PATCH 31/70] Update ClusterCompareAnaProcessor.cxx --- processors/src/ClusterCompareAnaProcessor.cxx | 44 ------------------- 1 file changed, 44 deletions(-) diff --git a/processors/src/ClusterCompareAnaProcessor.cxx b/processors/src/ClusterCompareAnaProcessor.cxx index bbdd12260..217473fb2 100644 --- a/processors/src/ClusterCompareAnaProcessor.cxx +++ b/processors/src/ClusterCompareAnaProcessor.cxx @@ -165,23 +165,6 @@ void ClusterCompareAnaProcessor::initialize(TTree* tree) { } } -/** - * - *THIS METHOD FILLS SEVERAL HISTOGRAMS FOR EACH EVENT DIRECTED AT EVALUATING CLUSTERING PERFORMANCE. FOR OUR TRACKING - *VARIABLES WE PLOT Z0 VS THE NUMBER OF SHARED HITS WITH AND WITHOUT A CLUSTER CUT (WE EXPECT A GOOD RECONSTRUCTION TO HAVE - *HAVE A LOW NUMBER OF SHARED CLUSTERS, ESPECIALLY AROUND THE Z0 VERTEX AND THAT THIS WOULD FURTHER IMPROVE WITH HIGH P TRACKS) - * - * - *TO FURTHER CHARACTERIZE THE CLUSTERS WE CAPTURE BASIC INFORMATION: CLUSTER AMPLITUDE, TIME, CHARGE, and STRIP CLUSTER POSITION - *AND DISTANCES. WE DO THIS FOR SHARED AND UNSHARED CLUSTERS. WE LARGELY IGNORE NTD, OR NEXT TO DEAD, ANALYSIS IN THIS PROCESSOR. - * - *THIS PROCESSOR IS UNDENIABLY EXTREMELY SIMILAR TO CLUSTERANAPROCESSOR, HAVING BEEN ITS OFFSPRING. THE MAIN DISTINCTION IS THAT - *THIS PROCESSOR IMPLEMENTS AN IDENTITY TRACKER (ident_) WHICH, ATM, IS IMPLEMENTED TO DETECT WHETHER AN EVENT IS IN TYPE 1 OR TYPE2 - *ALONG WITH A SHORT MACRO WHICH ASSOCIATES TO DIFFERENTLY RECONSTRUCTED ROOT FILES A IDENTIFICATION MONICER, THIS ALLOWS FOR QUICK - *DIRECT COMPARISON OF TWO MEANS OF RECONSTRUCTION. - * - * */ - bool ClusterCompareAnaProcessor::process(IEvent* ievent) { if(doingTracks_){ for(int i = 0;isize();i++){ @@ -327,12 +310,6 @@ bool ClusterCompareAnaProcessor::process(IEvent* ievent) { return true; } -/** - * - *THIS METHOD FILLS THE COLLECTION OF DEAD CHANNEL IDS GIVEN AN INPUT FILENAME. REQUIRED FOR NTD PLOTS, BUT LARGELY DISUSED IN THIS PROCESSOR AS OF YET. - * - * */ - void ClusterCompareAnaProcessor::fillDeads(){ for(int i = 0;i<24576;i++){ Deads_[i]=0.0; @@ -349,12 +326,6 @@ void ClusterCompareAnaProcessor::fillDeads(){ return; } -/** - * - *THIS METHOD GITS THE STRIP COUNT OUT OF ROUGHLY 25000 GIVEN THE FEB AND HYBRID IDS AND THE STRIP NO WRT THESE IDS - * - * */ - int ClusterCompareAnaProcessor::GetStrip(int feb,int hyb,int strip){ int BigCount = 0; if(feb<=1){ @@ -366,15 +337,6 @@ int ClusterCompareAnaProcessor::GetStrip(int feb,int hyb,int strip){ return BigCount; } -/** - * - *THE REMAINING METHODS (UP TO TRACKPLOT) ALL PLOT STANDARD HISTOGRAMS DESCRIBED IN THE DESCRIPTION TO THE PROCESS METHOD. - *THEY INCLUDE STANDARD FUNCTION CALLS YOU WOULD EXPECT IN A ROOT MACRO AND AFFORD SOME MORE CONTROL THAN A HISTOMANAGER AND - *REGION SELECTOR COMBO. - *FEASIBLE FOR A LIMITED NUMBER OF COLLECTION CUTS. - * - * */ - void ClusterCompareAnaProcessor::PlotClusterLayers(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); @@ -707,12 +669,6 @@ void ClusterCompareAnaProcessor::TrackTransverseMomenta(){ return; } -/** - * - *THE FINALIZE METHOD CALLS ALL THE PLOTTING MACROS ABOVE. THEY ARE CREATED INTO PNGS INTO THE REPOSITORY THE PROCESSOR IS CALLED IN. - * - * */ - void ClusterCompareAnaProcessor::finalize() { PlotClusterLayers(); PlotClusterCharges(); From 8f6336680456798f57424ee28adf433802297683 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 13:20:17 -0800 Subject: [PATCH 32/70] Update ClusterAnaProcessor.h --- processors/include/ClusterAnaProcessor.h | 46 +++++++++++++++++++++++- 1 file changed, 45 insertions(+), 1 deletion(-) diff --git a/processors/include/ClusterAnaProcessor.h b/processors/include/ClusterAnaProcessor.h index c8e95ed46..5c36a14e1 100644 --- a/processors/include/ClusterAnaProcessor.h +++ b/processors/include/ClusterAnaProcessor.h @@ -45,10 +45,36 @@ class ClusterAnaProcessor : public Processor { ~ClusterAnaProcessor(); + /** + * + *THIS METHOD FILLS SEVERAL HISTOGRAMS FOR EACH EVENT DIRECTED AT EVALUATING CLUSTERING PERFORMANCE. FOR OUR TRACKING + *VARIABLES WE PLOT Z0 VS THE NUMBER OF SHARED HITS WITH AND WITHOUT A CLUSTER CUT (WE EXPECT A GOOD RECONSTRUCTION TO HAVE + *HAVE A LOW NUMBER OF SHARED CLUSTERS, ESPECIALLY AROUND THE Z0 VERTEX AND THAT THIS WOULD FURTHER IMPROVE WITH HIGH P TRACKS) + * + * + *TO FURTHER CHARACTERIZE THE CLUSTERS WE CAPTURE BASIC INFORMATION: CLUSTER AMPLITUDE, TIME, CHARGE, and STRIP CLUSTER POSITION + *AND DISTANCES. WE DO THIS FOR SHARED AND UNSHARED CLUSTERS. WE LARGELY IGNORE NTD, OR NEXT TO DEAD, ANALYSIS IN THIS PROCESSOR. + * + *THIS PROCESSOR IS UNDENIABLY EXTREMELY SIMILAR TO CLUSTERANAPROCESSOR, HAVING BEEN ITS OFFSPRING. THE MAIN DISTINCTION IS THAT + *THIS PROCESSOR IMPLEMENTS AN IDENTITY TRACKER (ident_) WHICH, ATM, IS IMPLEMENTED TO DETECT WHETHER AN EVENT IS IN TYPE 1 OR TYPE2 + *ALONG WITH A SHORT MACRO WHICH ASSOCIATES TO DIFFERENTLY RECONSTRUCTED ROOT FILES A IDENTIFICATION MONICER, THIS ALLOWS FOR QUICK + *DIRECT COMPARISON OF TWO MEANS OF RECONSTRUCTION. + * + * */ + virtual bool process(IEvent* ievent); virtual void initialize(TTree* tree); + /** + * + *THE REMAINING METHODS (UP TO TRACKPLOT) ALL PLOT STANDARD HISTOGRAMS DESCRIBED IN THE DESCRIPTION TO THE PROCESS METHOD. + *THEY INCLUDE STANDARD FUNCTION CALLS YOU WOULD EXPECT IN A ROOT MACRO AND AFFORD SOME MORE CONTROL THAN A HISTOMANAGER AND + *REGION SELECTOR COMBO. + *FEASIBLE FOR A LIMITED NUMBER OF COLLECTION CUTS. + * + * */ + virtual void PlotClusterLayers(); virtual void PlotClusterLayersNTD(); @@ -65,10 +91,28 @@ class ClusterAnaProcessor : public Processor { virtual void TrackPlot1(); + /** + * + *THIS METHOD FILLS THE COLLECTION OF DEAD CHANNEL IDS GIVEN AN INPUT FILENAME. REQUIRED FOR NTD PLOTS, BUT LARGELY DISUSED IN THIS PROCESSOR AS OF YET. + * + * */ + virtual void fillDeads(); + /** + * + *THIS METHOD GITS THE STRIP COUNT OUT OF ROUGHLY 25000 GIVEN THE FEB AND HYBRID IDS AND THE STRIP NO WRT THESE IDS + * + * */ + virtual int GetStrip(int feb, int hyb,int strip); - + + /** + * + *THE FINALIZE METHOD CALLS ALL THE PLOTTING MACROS ABOVE. THEY ARE CREATED INTO PNGS INTO THE REPOSITORY THE PROCESSOR IS CALLED IN. + * + * */ + virtual void finalize(); virtual void configure(const ParameterSet& parameters); From 816cabbb69614902f35b223ec916ac16c547361a Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 13:22:51 -0800 Subject: [PATCH 33/70] Update ClusterAnaProcessor.cxx --- processors/src/ClusterAnaProcessor.cxx | 40 -------------------------- 1 file changed, 40 deletions(-) diff --git a/processors/src/ClusterAnaProcessor.cxx b/processors/src/ClusterAnaProcessor.cxx index 7cd882205..f00093094 100644 --- a/processors/src/ClusterAnaProcessor.cxx +++ b/processors/src/ClusterAnaProcessor.cxx @@ -109,19 +109,6 @@ void ClusterAnaProcessor::initialize(TTree* tree) { } } -/** - * - *THIS METHOD FILLS SEVERAL HISTOGRAMS FOR EACH EVENT DIRECTED AT EVALUATING CLUSTERING PERFORMANCE. FOR OUR TRACKING - *VARIABLES WE PLOT Z0 VS THE NUMBER OF SHARED HITS WITH AND WITHOUT A CLUSTER CUT (WE EXPECT A GOOD RECONSTRUCTION TO HAVE - *HAVE A LOW NUMBER OF SHARED CLUSTERS, ESPECIALLY AROUND THE Z0 VERTEX AND THAT THIS WOULD FURTHER IMPROVE WITH HIGH P TRACKS) - * - * - *TO FURTHER CHARACTERIZE THE CLUSTERS WE CAPTURE BASIC INFORMATION: CLUSTER AMPLITUDE, TIME, CHARGE, and STRIP CLUSTER POSITION - *AND DISTANCES. WE DO THIS FOR SHARED AND UNSHARED CLUSTERS. WE PERFORM THIS FILLING ALSO BASED ON A CLUSTER BEING NTD, MEANING - *NEXT TO DEAD. - * - * */ - bool ClusterAnaProcessor::process(IEvent* ievent) { if(doingTracks_){ for(int i = 0;isize();i++){ @@ -252,12 +239,6 @@ bool ClusterAnaProcessor::process(IEvent* ievent) { return true; } -/** - * - *THIS METHOD FILLS THE COLLECTION OF DEAD CHANNEL IDS GIVEN AN INPUT FILENAME. REQUIRED FOR NTD PLOTS - * - * */ - void ClusterAnaProcessor::fillDeads(){ for(int i = 0;i<24576;i++){ Deads_[i]=0.0; @@ -274,12 +255,6 @@ void ClusterAnaProcessor::fillDeads(){ return; } -/** - * - *THIS METHOD GITS THE STRIP COUNT OUT OF ROUGHLY 25000 GIVEN THE FEB AND HYBRID IDS AND THE STRIP NO WRT THESE IDS - * - * */ - int ClusterAnaProcessor::GetStrip(int feb,int hyb,int strip){ int BigCount = 0; if(feb<=1){ @@ -291,15 +266,6 @@ int ClusterAnaProcessor::GetStrip(int feb,int hyb,int strip){ return BigCount; } -/** - * - *THE REMAINING METHODS (UP TO TRACKPLOT) ALL PLOT STANDARD HISTOGRAMS DESCRIBED IN THE DESCRIPTION TO THE PROCESS METHOD. - *THEY INCLUDE STANDARD FUNCTION CALLS YOU WOULD EXPECT IN A ROOT MACRO AND AFFORD SOME MORE CONTROL THAN A HISTOMANAGER AND - *REGION SELECTOR COMBO. - *FEASIBLE FOR A LIMITED NUMBER OF COLLECTION CUTS. - * - * */ - void ClusterAnaProcessor::PlotClusterLayers(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); @@ -648,12 +614,6 @@ void ClusterAnaProcessor::TrackPlot(){ return; } -/** - * - *THE FINALIZE METHOD CALLS ALL THE PLOTTING MACROS ABOVE. THEY ARE CREATED INTO PNGS INTO THE REPOSITORY THE PROCESSOR IS CALLED IN. - * - * */ - void ClusterAnaProcessor::finalize() { PlotClusterLayers(); PlotClusterLayersNTD(); From b3bbd678c0ec58ea2e34d8bcb3e50487ea85e848 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 13:28:11 -0800 Subject: [PATCH 34/70] Update ClusterAnaProcessor.h --- processors/include/ClusterAnaProcessor.h | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/processors/include/ClusterAnaProcessor.h b/processors/include/ClusterAnaProcessor.h index 5c36a14e1..61f5a8fc1 100644 --- a/processors/include/ClusterAnaProcessor.h +++ b/processors/include/ClusterAnaProcessor.h @@ -53,12 +53,7 @@ class ClusterAnaProcessor : public Processor { * * *TO FURTHER CHARACTERIZE THE CLUSTERS WE CAPTURE BASIC INFORMATION: CLUSTER AMPLITUDE, TIME, CHARGE, and STRIP CLUSTER POSITION - *AND DISTANCES. WE DO THIS FOR SHARED AND UNSHARED CLUSTERS. WE LARGELY IGNORE NTD, OR NEXT TO DEAD, ANALYSIS IN THIS PROCESSOR. - * - *THIS PROCESSOR IS UNDENIABLY EXTREMELY SIMILAR TO CLUSTERANAPROCESSOR, HAVING BEEN ITS OFFSPRING. THE MAIN DISTINCTION IS THAT - *THIS PROCESSOR IMPLEMENTS AN IDENTITY TRACKER (ident_) WHICH, ATM, IS IMPLEMENTED TO DETECT WHETHER AN EVENT IS IN TYPE 1 OR TYPE2 - *ALONG WITH A SHORT MACRO WHICH ASSOCIATES TO DIFFERENTLY RECONSTRUCTED ROOT FILES A IDENTIFICATION MONICER, THIS ALLOWS FOR QUICK - *DIRECT COMPARISON OF TWO MEANS OF RECONSTRUCTION. + *AND DISTANCES. WE DO THIS FOR SHARED AND UNSHARED CLUSTERS. WE PERFORM THIS FOR REGULAR OR NTD (NEXT TO DEAD) CLUSTERS. * * */ From a8ca709c84537c7d461f2bcccafe7a11c2accec1 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 13:28:17 -0800 Subject: [PATCH 35/70] Update ClusterCompareAnaProcessor.h --- .../include/ClusterCompareAnaProcessor.h | 46 ++++++++++++++++++- 1 file changed, 45 insertions(+), 1 deletion(-) diff --git a/processors/include/ClusterCompareAnaProcessor.h b/processors/include/ClusterCompareAnaProcessor.h index 64fb4dc9c..3235a5a71 100644 --- a/processors/include/ClusterCompareAnaProcessor.h +++ b/processors/include/ClusterCompareAnaProcessor.h @@ -45,10 +45,36 @@ class ClusterCompareAnaProcessor : public Processor { ~ClusterCompareAnaProcessor(); + /** + * + *THIS METHOD FILLS SEVERAL HISTOGRAMS FOR EACH EVENT DIRECTED AT EVALUATING CLUSTERING PERFORMANCE. FOR OUR TRACKING + *VARIABLES WE PLOT Z0 VS THE NUMBER OF SHARED HITS WITH AND WITHOUT A CLUSTER CUT (WE EXPECT A GOOD RECONSTRUCTION TO HAVE + *HAVE A LOW NUMBER OF SHARED CLUSTERS, ESPECIALLY AROUND THE Z0 VERTEX AND THAT THIS WOULD FURTHER IMPROVE WITH HIGH P TRACKS) + *WE ALSO DIRECTLY COMPARE THE REGULAR AND TRANSVERSE MOMENTUM DISTRIBUTIONS FOR THE TWO METHODS. + * + *TO FURTHER CHARACTERIZE THE CLUSTERS WE CAPTURE BASIC INFORMATION: CLUSTER AMPLITUDE, TIME, CHARGE, and STRIP CLUSTER POSITION + *AND DISTANCES. WE DO THIS FOR SHARED AND UNSHARED CLUSTERS. WE LARGELY IGNORE NTD, OR NEXT TO DEAD, ANALYSIS IN THIS PROCESSOR. + * + *THIS PROCESSOR IS UNDENIABLY EXTREMELY SIMILAR TO CLUSTERANAPROCESSOR, HAVING BEEN ITS OFFSPRING. THE MAIN DISTINCTION IS THAT + *THIS PROCESSOR IMPLEMENTS AN IDENTITY TRACKER (ident_) WHICH, ATM, IS IMPLEMENTED TO DETECT WHETHER AN EVENT IS IN TYPE 1 OR TYPE2 + *ALONG WITH A SHORT MACRO WHICH ASSOCIATES TO DIFFERENTLY RECONSTRUCTED ROOT FILES A IDENTIFICATION MONICER, THIS ALLOWS FOR QUICK + *DIRECT COMPARISON OF TWO MEANS OF RECONSTRUCTION. + * + * */ + virtual bool process(IEvent* ievent); virtual void initialize(TTree* tree); + /** + * + *THE REMAINING METHODS (UP TO TRACKPLOT) ALL PLOT STANDARD HISTOGRAMS DESCRIBED IN THE DESCRIPTION TO THE PROCESS METHOD. + *THEY INCLUDE STANDARD FUNCTION CALLS YOU WOULD EXPECT IN A ROOT MACRO AND AFFORD SOME MORE CONTROL THAN A HISTOMANAGER AND + *REGION SELECTOR COMBO. + *FEASIBLE FOR A LIMITED NUMBER OF COLLECTION CUTS. + * + * */ + virtual void PlotClusterLayers(); virtual void PlotClusterCharges(); @@ -60,11 +86,29 @@ class ClusterCompareAnaProcessor : public Processor { virtual void TrackMomenta(); virtual void TrackTransverseMomenta(); - + + /** + * + *THIS METHOD FILLS THE COLLECTION OF DEAD CHANNEL IDS GIVEN AN INPUT FILENAME. REQUIRED FOR NTD PLOTS, BUT LARGELY DISUSED IN THIS PROCESSOR AS OF YET. + * + * */ + virtual void fillDeads(); + /** + * + *THIS METHOD GITS THE STRIP COUNT OUT OF ROUGHLY 25000 GIVEN THE FEB AND HYBRID IDS AND THE STRIP NO WRT THESE IDS + * + * */ + virtual int GetStrip(int feb, int hyb,int strip); + /** + * + *THE FINALIZE METHOD CALLS ALL THE PLOTTING MACROS ABOVE. THEY ARE CREATED INTO PNGS INTO THE REPOSITORY THE PROCESSOR IS CALLED IN. + * + * */ + virtual void finalize(); virtual void configure(const ParameterSet& parameters); From aa9916a675c68be087e30837a76a765832076b32 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 13:37:43 -0800 Subject: [PATCH 36/70] Update SvtRawDataAnaProcessor.h --- processors/include/SvtRawDataAnaProcessor.h | 40 ++++++++++++++++++--- 1 file changed, 36 insertions(+), 4 deletions(-) diff --git a/processors/include/SvtRawDataAnaProcessor.h b/processors/include/SvtRawDataAnaProcessor.h index 0b782e6d2..2cd0fd59c 100644 --- a/processors/include/SvtRawDataAnaProcessor.h +++ b/processors/include/SvtRawDataAnaProcessor.h @@ -43,22 +43,54 @@ class SvtRawDataAnaProcessor : public Processor { ~SvtRawDataAnaProcessor(); + /* + * + *RUNS OVER THE REGION SELECTORS AND CHECKS IF AN EVENT PASSES A SELECTION JSON AND FILLS A RAWSVTHITHISTO + IF DO SAMPLE IS ON, IT RUNS SAMPLING. + * + * + */ + virtual bool process(IEvent* ievent); + /* + * + *PROCESS INITIALIZER. READS IN THE OFFLINE BASELINES INTO LOCAL BASELINE FILES, READs in the PULSE SHAPES, and FINALLLY + ESTABLISHES REGIONS WHICH ARE USED ALONG WITH THE REGION SELECTOR CLASS AND CUTS IN ANALYSIS/SELECTION/SVT TO SELECT ON + EVENTS FOR WHICH HISTOGRAMS IN RAWSVTHISTO IS FILLED. + * + * + */ + virtual void initialize(TTree* tree); virtual void sample(RawSvtHit* thisHit, std::string word, IEvent* ievent, long t,int i); - - //virtual int hitEff(IEvent* ievent, int L); + + /* + * + *FOUR POLE PULSE FUNCTION AND THE SUM OF TWO OF THEM WITH BASELINES BORROWED FROM ALIC + * + */ virtual TF1* fourPoleFitFunction(std::string word, int caser); + /** + * + *THIS METHOD IS IMPLEMENTED BECAUSE C++ std:of METHOD WHICH CONVERTS STRINGS + *TO FLOATS IS NOT WORKING. WE NEED THIS TO READ IN OFFLINE BASELINES AND CHARACTERISTIC TIMES. + * + * + * */ + virtual float str_to_float(std::string word); float reverseEngineerTime(float ti, long t); - //virtual int maximum(int arr[]); - + /* + *FILLS IN HISTOGRAMS + * + */ + virtual void finalize(); virtual void configure(const ParameterSet& parameters); From 4fba76fe8b124875d58a4b5272cf8272ce0b9c9d Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 13:37:49 -0800 Subject: [PATCH 37/70] Update SvtRawDataAnaProcessor.cxx --- processors/src/SvtRawDataAnaProcessor.cxx | 40 ----------------------- 1 file changed, 40 deletions(-) diff --git a/processors/src/SvtRawDataAnaProcessor.cxx b/processors/src/SvtRawDataAnaProcessor.cxx index 4ccf214b5..a6297308e 100644 --- a/processors/src/SvtRawDataAnaProcessor.cxx +++ b/processors/src/SvtRawDataAnaProcessor.cxx @@ -37,15 +37,6 @@ void SvtRawDataAnaProcessor::configure(const ParameterSet& parameters) { } -/** - * - *THIS METHOD IS IMPLEMENTED BECAUSE C++ std:of METHOD WHICH CONVERTS STRINGS - TO FLOATS IS NOT WORKING. WE NEED THIS TO READ IN OFFLINE BASELINES AND CHARACTERISTIC TIMES. - * - * - * */ - - float SvtRawDataAnaProcessor::str_to_float(std::string token){ std::string top1=token.substr(0,token.find(".")); const char *top=top1.c_str(); @@ -90,13 +81,6 @@ float rETime(float ti,long T){ return ti; } - -/* - * - *FOUR POLE PULSE FUNCTION AND THE SUM OF TWO OF THEM WITH BASELINES BORROWED FROM ALIC - * - */ - TF1* SvtRawDataAnaProcessor::fourPoleFitFunction(std::string word, int caser){ const char *helper = word.data(); if(caser==0){ @@ -107,15 +91,6 @@ TF1* SvtRawDataAnaProcessor::fourPoleFitFunction(std::string word, int caser){ return func2; } -/* - * - *PROCESS INITIALIZER. READS IN THE OFFLINE BASELINES INTO LOCAL BASELINE FILES, READs in the PULSE SHAPES, and FINALLLY - ESTABLISHES REGIONS WHICH ARE USED ALONG WITH THE REGION SELECTOR CLASS AND CUTS IN ANALYSIS/SELECTION/SVT TO SELECT ON - EVENTS FOR WHICH HISTOGRAMS IN RAWSVTHISTO IS FILLED. - * - * - */ - void SvtRawDataAnaProcessor::initialize(TTree* tree) { if(doSample_){ //Fill in the Background Arrays @@ -201,15 +176,6 @@ void SvtRawDataAnaProcessor::initialize(TTree* tree) { } } -/* - * - *RUNS OVER THE REGION SELECTORS AND CHECKS IF AN EVENT PASSES A SELECTION JSON AND FILLS A RAWSVTHITHISTO - IF DO SAMPLE IS ON, IT RUNS SAMPLING. - * - * - */ - - bool SvtRawDataAnaProcessor::process(IEvent* ievent) { Float_t TimeRef=-0.0; Float_t AmpRef=1000.0; @@ -222,7 +188,6 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { int hitl = 0; float otherTime = 69420.0; - //ONLY POSITRONS, MAY USE FEE's //ONCE I DETERMINE A CLUSTER WHICH IS IN LINE WITH TRIG, I CAN USE ANY CLUSTERS CLOSE IN TIME. @@ -521,11 +486,6 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { } } - /* - *FILLS IN HISTOGRAMS - * - */ - void SvtRawDataAnaProcessor::finalize() { outF_->cd(); From d1c9152598a6ce579935f93465fe9b8b08fabe86 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 13:39:52 -0800 Subject: [PATCH 38/70] Update clusterCompareAna.py --- processors/config/clusterCompareAna.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/processors/config/clusterCompareAna.py b/processors/config/clusterCompareAna.py index d4afb424d..6d4c1595f 100644 --- a/processors/config/clusterCompareAna.py +++ b/processors/config/clusterCompareAna.py @@ -49,7 +49,7 @@ p.sequence = sequence -print("THE INPUT FILE IS "+str(root_file)) +print("processors::clusterAna: The input file is: "+str(root_file)) p.input_files = root_file p.output_files = [ana_file] From 8b6fde51525e75a6788286450b4eb349ced4dd42 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 13:40:23 -0800 Subject: [PATCH 39/70] Update clusterAna.py --- processors/config/clusterAna.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/processors/config/clusterAna.py b/processors/config/clusterAna.py index 9c372b89c..d364fba8d 100644 --- a/processors/config/clusterAna.py +++ b/processors/config/clusterAna.py @@ -49,7 +49,7 @@ p.sequence = sequence -print("THE INPUT FILE IS "+str(root_file)) +print("processors::clusterAna: The input file is: "+str(root_file)) p.input_files = root_file p.output_files = [ana_file] From 79f3bc0b8b15c18635496f9067433680b944a68f Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 16:46:29 -0800 Subject: [PATCH 40/70] Update SvtRawDataAnaProcessor.cxx --- processors/src/SvtRawDataAnaProcessor.cxx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/processors/src/SvtRawDataAnaProcessor.cxx b/processors/src/SvtRawDataAnaProcessor.cxx index a6297308e..0ae64cef6 100644 --- a/processors/src/SvtRawDataAnaProcessor.cxx +++ b/processors/src/SvtRawDataAnaProcessor.cxx @@ -198,8 +198,8 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { Clusters_->at(i)->getLayer(); } - for(unsigned int i = 0; i < svtHits_->size(); i++){ - RawSvtHit * thisHit = svtHits_->at(i); + for(unsigned int I = 0; I < svtHits_->size(); I++){ + RawSvtHit * thisHit = svtHits_->at(I); int getNum = thisHit->getFitN(); if(doClMatch){ bool Continue = true; @@ -345,7 +345,7 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { sample(thisHit,regions_[i_reg],ievent,eventTime,N); } - reg_histos_[regions_[i_reg]]->FillHistograms(thisHit,weight,J,i,TimeDiff,AmpDiff,stripID,hitc,hitl,otherTime); + reg_histos_[regions_[i_reg]]->FillHistograms(thisHit,weight,J,I,TimeDiff,AmpDiff,stripID,hitc,hitl,otherTime); } } } From 8aa2e1b87990545cdefc49ccd5772e6823fc9546 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:14:47 -0800 Subject: [PATCH 41/70] Update ClusterCompareAnaProcessor.cxx --- processors/src/ClusterCompareAnaProcessor.cxx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/processors/src/ClusterCompareAnaProcessor.cxx b/processors/src/ClusterCompareAnaProcessor.cxx index 217473fb2..4e7a377ba 100644 --- a/processors/src/ClusterCompareAnaProcessor.cxx +++ b/processors/src/ClusterCompareAnaProcessor.cxx @@ -186,12 +186,12 @@ bool ClusterCompareAnaProcessor::process(IEvent* ievent) { } //Transverse Track Momentum for same cuts - if(ident_<1.5){TrackMomentumTAllTime1_->Fill(track->getP());}else{TrackMomentumTAllTime2_->Fill(track->getP());} + if(ident_<1.5){TrackMomentumTAllTime1_->Fill(track->getPt());}else{TrackMomentumTAllTime2_->Fill(track->getPt());} if(track->getTrackTime()*track->getTrackTime()<16.0){ - if(ident_<1.5){TrackMomentumTInTime1_->Fill(track->getP());}else{TrackMomentumTInTime2_->Fill(track->getP());} + if(ident_<1.5){TrackMomentumTInTime1_->Fill(track->getPt());}else{TrackMomentumTInTime2_->Fill(track->getPt());} }else{ - if(ident_<1.5){TrackMomentumTOutTime1_->Fill(track->getP());}else{TrackMomentumTOutTime2_->Fill(track->getPt());} + if(ident_<1.5){TrackMomentumTOutTime1_->Fill(track->getPt());}else{TrackMomentumTOutTime2_->Fill(track->getPt());} } } } From e080a808636aaa1d538ba65bf135323f4eac7ed1 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:20:55 -0800 Subject: [PATCH 42/70] Add files via upload --- processors/dat/badchannels2021.dat | 873 +++++++++++++++++++++++++++++ 1 file changed, 873 insertions(+) create mode 100644 processors/dat/badchannels2021.dat diff --git a/processors/dat/badchannels2021.dat b/processors/dat/badchannels2021.dat new file mode 100644 index 000000000..aaf20c467 --- /dev/null +++ b/processors/dat/badchannels2021.dat @@ -0,0 +1,873 @@ +svt_channel_id +470 +802 +1145 +1320 +2371 +2448 +3443 +3444 +3966 +4737 +4739 +4745 +4747 +4749 +4751 +4753 +4755 +5364 +5374 +6624 +7819 +7966 +8001 +8574 +9203 +11776 +11777 +11778 +11779 +11780 +11781 +11782 +11783 +11784 +11785 +11786 +11787 +11788 +11789 +11790 +11791 +11792 +11793 +11794 +11795 +11796 +11797 +11798 +11799 +11800 +11801 +11802 +11803 +11804 +11805 +11806 +11807 +11808 +11809 +11810 +11811 +11812 +11813 +11814 +11815 +11816 +11817 +11818 +11819 +11820 +11821 +11822 +11823 +11824 +11825 +11826 +11827 +11828 +11829 +11830 +11831 +11832 +11833 +11834 +11835 +11836 +11837 +11838 +11839 +11840 +11841 +11842 +11843 +11844 +11845 +11846 +11847 +11848 +11849 +11850 +11851 +11852 +11853 +11854 +11855 +11856 +11857 +11858 +11859 +11860 +11861 +11862 +11863 +11864 +11865 +11866 +11867 +11868 +11869 +11870 +11871 +11872 +11873 +11874 +11875 +11876 +11877 +11878 +11879 +11880 +11881 +11882 +11883 +11884 +11885 +11886 +11887 +11888 +11889 +11890 +11891 +11892 +11893 +11894 +11895 +11896 +11897 +11898 +11899 +11900 +11901 +11902 +11903 +11904 +11905 +11906 +11907 +11908 +11909 +11910 +11911 +11912 +11913 +11914 +11915 +11916 +11917 +11918 +11919 +11920 +11921 +11922 +11923 +11924 +11925 +11926 +11927 +11928 +11929 +11930 +11931 +11932 +11933 +11934 +11935 +11936 +11937 +11938 +11939 +11940 +11941 +11942 +11943 +11944 +11945 +11946 +11947 +11948 +11949 +11950 +11951 +11952 +11953 +11954 +11955 +11956 +11957 +11958 +11959 +11960 +11961 +11962 +11963 +11964 +11965 +11966 +11967 +11968 +11969 +11970 +11971 +11972 +11973 +11974 +11975 +11976 +11977 +11978 +11979 +11980 +11981 +11982 +11983 +11984 +11985 +11986 +11987 +11988 +11989 +11990 +11991 +11992 +11993 +11994 +11995 +11996 +11997 +11998 +11999 +12000 +12001 +12002 +12003 +12004 +12005 +12006 +12007 +12008 +12009 +12010 +12011 +12012 +12013 +12014 +12015 +12016 +12017 +12018 +12019 +12020 +12021 +12022 +12023 +12024 +12025 +12026 +12027 +12028 +12029 +12030 +12031 +12032 +12033 +12034 +12035 +12036 +12037 +12038 +12039 +12040 +12041 +12042 +12043 +12044 +12045 +12046 +12047 +12048 +12049 +12050 +12051 +12052 +12053 +12054 +12055 +12056 +12057 +12058 +12059 +12060 +12061 +12062 +12063 +12064 +12065 +12066 +12067 +12068 +12069 +12070 +12071 +12072 +12073 +12074 +12075 +12076 +12077 +12078 +12079 +12080 +12081 +12082 +12083 +12084 +12085 +12086 +12087 +12088 +12089 +12090 +12091 +12092 +12093 +12094 +12095 +12096 +12097 +12098 +12099 +12100 +12101 +12102 +12103 +12104 +12105 +12106 +12107 +12108 +12109 +12110 +12111 +12112 +12113 +12114 +12115 +12116 +12117 +12118 +12119 +12120 +12121 +12122 +12123 +12124 +12125 +12126 +12127 +12128 +12129 +12130 +12131 +12132 +12133 +12134 +12135 +12136 +12137 +12138 +12139 +12140 +12141 +12142 +12143 +12144 +12145 +12146 +12147 +12148 +12149 +12150 +12151 +12152 +12153 +12154 +12155 +12156 +12157 +12158 +12159 +12160 +12161 +12162 +12163 +12164 +12165 +12166 +12167 +12168 +12169 +12170 +12171 +12172 +12173 +12174 +12175 +12176 +12177 +12178 +12179 +12180 +12181 +12182 +12183 +12184 +12185 +12186 +12187 +12188 +12189 +12190 +12191 +12192 +12193 +12194 +12195 +12196 +12197 +12198 +12199 +12200 +12201 +12202 +12203 +12204 +12205 +12206 +12207 +12208 +12209 +12210 +12211 +12212 +12213 +12214 +12215 +12216 +12217 +12218 +12219 +12220 +12221 +12222 +12223 +12224 +12225 +12226 +12227 +12228 +12229 +12230 +12231 +12232 +12233 +12234 +12235 +12236 +12237 +12238 +12239 +12240 +12241 +12242 +12243 +12244 +12245 +12246 +12247 +12248 +12249 +12250 +12251 +12252 +12253 +12254 +12255 +12256 +12257 +12258 +12259 +12260 +12261 +12262 +12263 +12264 +12265 +12266 +12267 +12268 +12269 +12270 +12271 +12272 +12273 +12274 +12275 +12276 +12277 +12278 +12279 +12280 +12281 +12282 +12283 +12284 +12285 +12286 +12287 +12288 +12289 +12290 +12291 +12292 +12293 +12294 +12295 +12296 +12297 +12298 +12299 +12300 +12301 +12302 +12303 +12304 +12305 +12306 +12307 +12308 +12309 +12310 +12311 +12312 +12313 +12314 +12315 +12316 +12317 +12318 +12319 +12320 +12321 +12322 +12323 +12324 +12325 +12326 +12327 +12328 +12329 +12330 +12331 +12332 +12333 +12334 +12335 +12336 +12337 +12338 +12339 +12340 +12341 +12342 +12343 +12344 +12345 +12346 +12347 +12348 +12349 +12350 +12351 +12352 +12353 +12354 +12355 +12356 +12357 +12358 +12359 +12360 +12361 +12362 +12363 +12364 +12365 +12366 +12367 +12368 +12369 +12370 +12371 +12372 +12373 +12374 +12375 +12376 +12377 +12378 +12379 +12380 +12381 +12382 +12383 +12384 +12385 +12386 +12387 +12388 +12389 +12390 +12391 +12392 +12393 +12394 +12395 +12396 +12397 +12398 +12399 +12400 +12401 +12402 +12403 +12404 +12405 +12406 +12407 +12408 +12409 +12410 +12411 +12412 +12413 +12414 +12415 +12461 +12526 +12630 +13311 +13889 +14143 +15290 +16063 +16127 +16767 +18868 +18869 +19968 +19969 +19970 +19971 +19972 +19973 +19974 +19975 +19976 +19977 +19978 +19979 +19980 +19981 +19982 +19983 +19984 +19985 +19986 +19987 +19988 +19989 +19990 +19991 +19992 +19993 +19994 +19995 +19996 +19997 +19998 +19999 +20000 +20001 +20002 +20003 +20004 +20005 +20006 +20007 +20008 +20009 +20010 +20011 +20012 +20013 +20014 +20015 +20016 +20017 +20018 +20019 +20020 +20021 +20022 +20023 +20024 +20025 +20026 +20027 +20028 +20029 +20030 +20031 +20032 +20033 +20034 +20035 +20036 +20037 +20038 +20039 +20040 +20041 +20042 +20043 +20044 +20045 +20046 +20047 +20048 +20049 +20050 +20051 +20052 +20053 +20054 +20055 +20056 +20057 +20058 +20059 +20060 +20061 +20062 +20063 +20064 +20065 +20066 +20067 +20068 +20069 +20070 +20071 +20072 +20073 +20074 +20075 +20076 +20077 +20078 +20079 +20080 +20081 +20082 +20083 +20084 +20085 +20086 +20087 +20088 +20089 +20090 +20091 +20092 +20093 +20094 +20095 +20863 +20991 +21117 +21119 +21121 +21183 +21247 +21311 +21313 +21315 +21439 +21501 +21503 +21567 +21631 +21697 +21759 +21761 +21821 +21823 +21887 +21889 +21949 +21951 +21953 +21977 +21978 +21979 +21980 +21981 +21982 +21983 +21984 +21985 +21986 +21987 +21988 +21989 +21990 +21991 +21992 +21993 +21994 +21995 +21996 +21997 +21998 +21999 +22000 +22001 +22002 +22003 +22004 +22005 +22006 +22007 +22008 +22009 +22010 +22011 +22012 +22013 +22014 +22015 +22271 +23872 +23874 From 152581bf9f6f94738abf682593484a1b6818882b Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:24:25 -0800 Subject: [PATCH 43/70] Update clusterAna.py --- processors/config/clusterAna.py | 1 + 1 file changed, 1 insertion(+) diff --git a/processors/config/clusterAna.py b/processors/config/clusterAna.py index d364fba8d..c723f9884 100644 --- a/processors/config/clusterAna.py +++ b/processors/config/clusterAna.py @@ -44,6 +44,7 @@ clua.parameters["isMC"] = options.isMC clua.parameters["doTrack"] = options.doTrack clua.parameters["cut"] = options.cut +clua.parameters["badchannels"] = os.environ['HPSTR_BASE']+"/processors/dat/badchannels2021.dat" sequence = [clua] From 7dcd3bd8649d0d3a6d6c15e9bb71c5a21d757b3e Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:24:51 -0800 Subject: [PATCH 44/70] Update clusterCompareAna.py --- processors/config/clusterCompareAna.py | 1 + 1 file changed, 1 insertion(+) diff --git a/processors/config/clusterCompareAna.py b/processors/config/clusterCompareAna.py index 6d4c1595f..074adc887 100644 --- a/processors/config/clusterCompareAna.py +++ b/processors/config/clusterCompareAna.py @@ -44,6 +44,7 @@ cclua.parameters["isMC"] = options.isMC cclua.parameters["doTrack"] = options.doTrack cclua.parameters["cut"] = options.cut +cclua.parameters["badchannels"] = os.environ['HPSTR_BASE']+"/processors/dat/badchannels2021.dat" sequence = [cclua] From 980859783bfb4c4d8694c3642d62570db3325e4f Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:26:46 -0800 Subject: [PATCH 45/70] Update ClusterCompareAnaProcessor.cxx --- processors/src/ClusterCompareAnaProcessor.cxx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/processors/src/ClusterCompareAnaProcessor.cxx b/processors/src/ClusterCompareAnaProcessor.cxx index 4e7a377ba..e94eb1c42 100644 --- a/processors/src/ClusterCompareAnaProcessor.cxx +++ b/processors/src/ClusterCompareAnaProcessor.cxx @@ -23,6 +23,7 @@ void ClusterCompareAnaProcessor::configure(const ParameterSet& parameters) { isMC_ = parameters.getInteger("isMC"); doingTracks_ = (parameters.getInteger("doTrack")==1); pcut_ = (float)parameters.getDouble("cut"); + badchann_ = parameters.getString("badchannels"); } catch (std::runtime_error& error) { @@ -314,7 +315,7 @@ void ClusterCompareAnaProcessor::fillDeads(){ for(int i = 0;i<24576;i++){ Deads_[i]=0.0; } - std::string FILENAME="/sdf/group/hps/users/rodwyer1/run/cluster_study/badchannels2021.dat"; + std::string FILENAME=badchann_; std::ifstream file(FILENAME.c_str()); std::string line; std::getline(file,line); From af81dc1ef8b3de605ee0bd2b1e5b619bd044a3a2 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:27:23 -0800 Subject: [PATCH 46/70] Update ClusterCompareAnaProcessor.h --- processors/include/ClusterCompareAnaProcessor.h | 1 + 1 file changed, 1 insertion(+) diff --git a/processors/include/ClusterCompareAnaProcessor.h b/processors/include/ClusterCompareAnaProcessor.h index 3235a5a71..90d4b618a 100644 --- a/processors/include/ClusterCompareAnaProcessor.h +++ b/processors/include/ClusterCompareAnaProcessor.h @@ -228,6 +228,7 @@ class ClusterCompareAnaProcessor : public Processor { int debug_{0}; int isMC_{0}; float ident_{1.0}; + std::string badchann_{""}; }; #endif From e1de849c3f8ff98f799ce056bc22a09c71ac8072 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:27:51 -0800 Subject: [PATCH 47/70] Update ClusterAnaProcessor.h --- processors/include/ClusterAnaProcessor.h | 1 + 1 file changed, 1 insertion(+) diff --git a/processors/include/ClusterAnaProcessor.h b/processors/include/ClusterAnaProcessor.h index 61f5a8fc1..263736ea6 100644 --- a/processors/include/ClusterAnaProcessor.h +++ b/processors/include/ClusterAnaProcessor.h @@ -177,6 +177,7 @@ class ClusterAnaProcessor : public Processor { //std::string anaName_{"ClusterAna"}; int debug_{0}; int isMC_{0}; + std::string badchann_{""}; }; #endif From 75105000485935ff55ad37413b2fa0dc4def6b5a Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:28:47 -0800 Subject: [PATCH 48/70] Update ClusterAnaProcessor.cxx --- processors/src/ClusterAnaProcessor.cxx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/processors/src/ClusterAnaProcessor.cxx b/processors/src/ClusterAnaProcessor.cxx index f00093094..1ff6ce8ac 100644 --- a/processors/src/ClusterAnaProcessor.cxx +++ b/processors/src/ClusterAnaProcessor.cxx @@ -23,6 +23,7 @@ void ClusterAnaProcessor::configure(const ParameterSet& parameters) { isMC_ = parameters.getInteger("isMC"); doingTracks_ = (parameters.getInteger("doTrack")==1); pcut_ = (float)parameters.getDouble("cut"); + badchann_ = parameters.getString("badchannels"); //anaName_ = parameters.getString("anaName"); } catch (std::runtime_error& error) @@ -243,7 +244,7 @@ void ClusterAnaProcessor::fillDeads(){ for(int i = 0;i<24576;i++){ Deads_[i]=0.0; } - std::string FILENAME="/sdf/group/hps/users/rodwyer1/run/cluster_study/badchannels2021.dat"; + std::string FILENAME=badchann_; std::ifstream file(FILENAME.c_str()); std::string line; std::getline(file,line); From f22f8084cea53df74094136f5f06f22eb2fb8682 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:33:23 -0800 Subject: [PATCH 49/70] Update and rename ClusterCompareAnaProcessor.h to TrackHitCompareAnaProcessor.h --- ...usterCompareAnaProcessor.h => TrackHitCompareAnaProcessor.h} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename processors/include/{ClusterCompareAnaProcessor.h => TrackHitCompareAnaProcessor.h} (99%) diff --git a/processors/include/ClusterCompareAnaProcessor.h b/processors/include/TrackHitCompareAnaProcessor.h similarity index 99% rename from processors/include/ClusterCompareAnaProcessor.h rename to processors/include/TrackHitCompareAnaProcessor.h index 90d4b618a..3d24bf1e6 100644 --- a/processors/include/ClusterCompareAnaProcessor.h +++ b/processors/include/TrackHitCompareAnaProcessor.h @@ -1,4 +1,4 @@ -#ifndef __CLUSTERCOMPARE_ANAPROCESSOR_H__ +#ifndef __T_ANAPROCESSOR_H__ #define __CLUSTERCOMPARE_ANAPROCESSOR_H__ //HPSTR From 6cf9e35484d683f602e22c8a1f048fad28bd23ff Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:33:49 -0800 Subject: [PATCH 50/70] Update TrackHitCompareAnaProcessor.h --- processors/include/TrackHitCompareAnaProcessor.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/processors/include/TrackHitCompareAnaProcessor.h b/processors/include/TrackHitCompareAnaProcessor.h index 3d24bf1e6..8b694a5ae 100644 --- a/processors/include/TrackHitCompareAnaProcessor.h +++ b/processors/include/TrackHitCompareAnaProcessor.h @@ -1,5 +1,5 @@ -#ifndef __T_ANAPROCESSOR_H__ -#define __CLUSTERCOMPARE_ANAPROCESSOR_H__ +#ifndef __TRACKHITCOMPARE_ANAPROCESSOR_H__ +#define __TRACKHITCOMPARE_ANAPROCESSOR_H__ //HPSTR #include "HpsEvent.h" From 60b6f2f5458872818ed0f3a31f217847119d173c Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:34:53 -0800 Subject: [PATCH 51/70] Update TrackHitCompareAnaProcessor.h --- processors/include/TrackHitCompareAnaProcessor.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/processors/include/TrackHitCompareAnaProcessor.h b/processors/include/TrackHitCompareAnaProcessor.h index 8b694a5ae..ce10c3054 100644 --- a/processors/include/TrackHitCompareAnaProcessor.h +++ b/processors/include/TrackHitCompareAnaProcessor.h @@ -37,13 +37,13 @@ class TTree; -class ClusterCompareAnaProcessor : public Processor { +class TrackHitCompareAnaProcessor : public Processor { public: - ClusterCompareAnaProcessor(const std::string& name, Process& process); + TrackHitCompareAnaProcessor(const std::string& name, Process& process); - ~ClusterCompareAnaProcessor(); + ~TrackHitCompareAnaProcessor(); /** * From 196ac7acdf7cfaac6669fda10c94fa714e44f18e Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:36:01 -0800 Subject: [PATCH 52/70] Update and rename ClusterCompareAnaProcessor.cxx to TrackHitCompareAnaProcessor.cxx --- ...or.cxx => TrackHitCompareAnaProcessor.cxx} | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) rename processors/src/{ClusterCompareAnaProcessor.cxx => TrackHitCompareAnaProcessor.cxx} (96%) diff --git a/processors/src/ClusterCompareAnaProcessor.cxx b/processors/src/TrackHitCompareAnaProcessor.cxx similarity index 96% rename from processors/src/ClusterCompareAnaProcessor.cxx rename to processors/src/TrackHitCompareAnaProcessor.cxx index e94eb1c42..d68df7e0f 100644 --- a/processors/src/ClusterCompareAnaProcessor.cxx +++ b/processors/src/TrackHitCompareAnaProcessor.cxx @@ -1,20 +1,20 @@ /** - * @file ClusterCompareAnaProcessor.cxx + * @file TrackHitAnaProcessor.cxx * @brief AnaProcessor used to compare two means of reconstruction directly. Fills histograms to study cluster reconstruction algorithms and dead channels. * Does not feature a region selector or histomanager (i.e. no configurable json files), rather * for the limited featured plots allows for more specific manipulation and control. * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory */ -#include "ClusterCompareAnaProcessor.h" +#include "TrackHitCompareAnaProcessor.h" #include -ClusterCompareAnaProcessor::ClusterCompareAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ +TrackHitAnaProcessor::TrackHitAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ mmapper_ = new ModuleMapper(2021); } -ClusterCompareAnaProcessor::~ClusterCompareAnaProcessor(){} +TrackHitAnaProcessor::~TrackHitAnaProcessor(){} -void ClusterCompareAnaProcessor::configure(const ParameterSet& parameters) { - std::cout << "Configuring ClusterCompareAnaProcessor" << std::endl; +void TrackHitAnaProcessor::configure(const ParameterSet& parameters) { + std::cout << "Configuring TrackHitAnaProcessor" << std::endl; try { debug_ = parameters.getInteger("debug"); @@ -33,7 +33,7 @@ void ClusterCompareAnaProcessor::configure(const ParameterSet& parameters) { } -void ClusterCompareAnaProcessor::initialize(TTree* tree) { +void TrackHitAnaProcessor::initialize(TTree* tree) { fillDeads(); tree_= tree; if(isMC_==1){ @@ -166,7 +166,7 @@ void ClusterCompareAnaProcessor::initialize(TTree* tree) { } } -bool ClusterCompareAnaProcessor::process(IEvent* ievent) { +bool TrackHitAnaProcessor::process(IEvent* ievent) { if(doingTracks_){ for(int i = 0;isize();i++){ Track* track = tracks_->at(i); @@ -311,7 +311,7 @@ bool ClusterCompareAnaProcessor::process(IEvent* ievent) { return true; } -void ClusterCompareAnaProcessor::fillDeads(){ +void TrackHitAnaProcessor::fillDeads(){ for(int i = 0;i<24576;i++){ Deads_[i]=0.0; } @@ -327,7 +327,7 @@ void ClusterCompareAnaProcessor::fillDeads(){ return; } -int ClusterCompareAnaProcessor::GetStrip(int feb,int hyb,int strip){ +int TrackHitAnaProcessor::GetStrip(int feb,int hyb,int strip){ int BigCount = 0; if(feb<=1){ BigCount+=feb*2048+hyb*512+strip; @@ -338,7 +338,7 @@ int ClusterCompareAnaProcessor::GetStrip(int feb,int hyb,int strip){ return BigCount; } -void ClusterCompareAnaProcessor::PlotClusterLayers(){ +void TrackHitAnaProcessor::PlotClusterLayers(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -396,7 +396,7 @@ void ClusterCompareAnaProcessor::PlotClusterLayers(){ return; } -void ClusterCompareAnaProcessor::PlotClusterCharges(){ +void TrackHitAnaProcessor::PlotClusterCharges(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); @@ -454,7 +454,7 @@ void ClusterCompareAnaProcessor::PlotClusterCharges(){ return; } -void ClusterCompareAnaProcessor::PlotClusterTimes(){ +void TrackHitAnaProcessor::PlotClusterTimes(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); @@ -513,7 +513,7 @@ void ClusterCompareAnaProcessor::PlotClusterTimes(){ return; } -void ClusterCompareAnaProcessor::PlotClusterPositions(){ +void TrackHitAnaProcessor::PlotClusterPositions(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); @@ -567,7 +567,7 @@ void ClusterCompareAnaProcessor::PlotClusterPositions(){ return; } -void ClusterCompareAnaProcessor::TrackMomenta(){ +void TrackHitAnaProcessor::TrackMomenta(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); gPad->SetLogy(false); @@ -619,7 +619,7 @@ void ClusterCompareAnaProcessor::TrackMomenta(){ return; } -void ClusterCompareAnaProcessor::TrackTransverseMomenta(){ +void TrackHitAnaProcessor::TrackTransverseMomenta(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); gPad->SetLogy(false); @@ -670,7 +670,7 @@ void ClusterCompareAnaProcessor::TrackTransverseMomenta(){ return; } -void ClusterCompareAnaProcessor::finalize() { +void TrackHitAnaProcessor::finalize() { PlotClusterLayers(); PlotClusterCharges(); PlotClusterTimes(); @@ -681,4 +681,4 @@ void ClusterCompareAnaProcessor::finalize() { } return; } -DECLARE_PROCESSOR(ClusterCompareAnaProcessor); +DECLARE_PROCESSOR(TrackHitAnaProcessor); From 430020f8ee5e310906a77165ef75cd452952894f Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:41:30 -0800 Subject: [PATCH 53/70] Update and rename ClusterAnaProcessor.h to SVTClusterAnaProcessor.h --- ...{ClusterAnaProcessor.h => SVTClusterAnaProcessor.h} | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) rename processors/include/{ClusterAnaProcessor.h => SVTClusterAnaProcessor.h} (95%) diff --git a/processors/include/ClusterAnaProcessor.h b/processors/include/SVTClusterAnaProcessor.h similarity index 95% rename from processors/include/ClusterAnaProcessor.h rename to processors/include/SVTClusterAnaProcessor.h index 263736ea6..27953e6b3 100644 --- a/processors/include/ClusterAnaProcessor.h +++ b/processors/include/SVTClusterAnaProcessor.h @@ -1,5 +1,5 @@ -#ifndef __CLUSTER_ANAPROCESSOR_H__ -#define __CLUSTER_ANAPROCESSOR_H__ +#ifndef __SVTCLUSTER_ANAPROCESSOR_H__ +#define __SVTCLUSTER_ANAPROCESSOR_H__ //HPSTR #include "HpsEvent.h" @@ -37,13 +37,13 @@ class TTree; -class ClusterAnaProcessor : public Processor { +class SvtClusterAnaProcessor : public Processor { public: - ClusterAnaProcessor(const std::string& name, Process& process); + SvtClusterAnaProcessor(const std::string& name, Process& process); - ~ClusterAnaProcessor(); + ~SvtClusterAnaProcessor(); /** * From 880994a94c8a61af02cd8d5b075391f9f45ec20e Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:43:15 -0800 Subject: [PATCH 54/70] Update and rename ClusterAnaProcessor.cxx to SVTClusterAnaProcessor.cxx --- ...ocessor.cxx => SVTClusterAnaProcessor.cxx} | 40 +++++++++---------- 1 file changed, 20 insertions(+), 20 deletions(-) rename processors/src/{ClusterAnaProcessor.cxx => SVTClusterAnaProcessor.cxx} (95%) diff --git a/processors/src/ClusterAnaProcessor.cxx b/processors/src/SVTClusterAnaProcessor.cxx similarity index 95% rename from processors/src/ClusterAnaProcessor.cxx rename to processors/src/SVTClusterAnaProcessor.cxx index 1ff6ce8ac..f1d7a6d09 100644 --- a/processors/src/ClusterAnaProcessor.cxx +++ b/processors/src/SVTClusterAnaProcessor.cxx @@ -1,20 +1,20 @@ /** - * @file ClusterAnaProcessor.cxx + * @file SVTClusterAnaProcessor.cxx * @brief AnaProcessor used fill histograms to study cluster reconstruction algorithms and dead channels. * Does not feature a region selector or histomanager (i.e. no configurable json files), rather * for the limited featured plots allows for more specific manipulation and control. * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory */ -#include "ClusterAnaProcessor.h" +#include "SVTClusterAnaProcessor.h" #include -ClusterAnaProcessor::ClusterAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ +SVTClusterAnaProcessor::SVTClusterAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ mmapper_ = new ModuleMapper(2021); } -ClusterAnaProcessor::~ClusterAnaProcessor(){} +SVTClusterAnaProcessor::~SVTClusterAnaProcessor(){} -void ClusterAnaProcessor::configure(const ParameterSet& parameters) { - std::cout << "Configuring ClusterAnaProcessor" << std::endl; +void SVTClusterAnaProcessor::configure(const ParameterSet& parameters) { + std::cout << "Configuring SVTClusterAnaProcessor" << std::endl; try { debug_ = parameters.getInteger("debug"); @@ -33,7 +33,7 @@ void ClusterAnaProcessor::configure(const ParameterSet& parameters) { } -void ClusterAnaProcessor::initialize(TTree* tree) { +void SVTClusterAnaProcessor::initialize(TTree* tree) { fillDeads(); tree_= tree; @@ -110,7 +110,7 @@ void ClusterAnaProcessor::initialize(TTree* tree) { } } -bool ClusterAnaProcessor::process(IEvent* ievent) { +bool SVTClusterAnaProcessor::process(IEvent* ievent) { if(doingTracks_){ for(int i = 0;isize();i++){ Track* track = tracks_->at(i); @@ -240,7 +240,7 @@ bool ClusterAnaProcessor::process(IEvent* ievent) { return true; } -void ClusterAnaProcessor::fillDeads(){ +void SVTClusterAnaProcessor::fillDeads(){ for(int i = 0;i<24576;i++){ Deads_[i]=0.0; } @@ -256,7 +256,7 @@ void ClusterAnaProcessor::fillDeads(){ return; } -int ClusterAnaProcessor::GetStrip(int feb,int hyb,int strip){ +int SVTClusterAnaProcessor::GetStrip(int feb,int hyb,int strip){ int BigCount = 0; if(feb<=1){ BigCount+=feb*2048+hyb*512+strip; @@ -267,7 +267,7 @@ int ClusterAnaProcessor::GetStrip(int feb,int hyb,int strip){ return BigCount; } -void ClusterAnaProcessor::PlotClusterLayers(){ +void SVTClusterAnaProcessor::PlotClusterLayers(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -310,7 +310,7 @@ void ClusterAnaProcessor::PlotClusterLayers(){ return; } -void ClusterAnaProcessor::PlotClusterCharges(){ +void SVTClusterAnaProcessor::PlotClusterCharges(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -354,7 +354,7 @@ void ClusterAnaProcessor::PlotClusterCharges(){ return; } -void ClusterAnaProcessor::PlotClusterLayersNTD(){ +void SVTClusterAnaProcessor::PlotClusterLayersNTD(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -397,7 +397,7 @@ void ClusterAnaProcessor::PlotClusterLayersNTD(){ return; } -void ClusterAnaProcessor::PlotClusterChargesNTD(){ +void SVTClusterAnaProcessor::PlotClusterChargesNTD(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -441,7 +441,7 @@ void ClusterAnaProcessor::PlotClusterChargesNTD(){ return; } -void ClusterAnaProcessor::PlotClusterPositions(){ +void SVTClusterAnaProcessor::PlotClusterPositions(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -479,7 +479,7 @@ void ClusterAnaProcessor::PlotClusterPositions(){ c1->Clear(); } -void ClusterAnaProcessor::PlotClusterTimes(){ +void SVTClusterAnaProcessor::PlotClusterTimes(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -522,7 +522,7 @@ void ClusterAnaProcessor::PlotClusterTimes(){ return; } -void ClusterAnaProcessor::PlotClusterTimesNTD(){ +void SVTClusterAnaProcessor::PlotClusterTimesNTD(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -565,7 +565,7 @@ void ClusterAnaProcessor::PlotClusterTimesNTD(){ return; } -void ClusterAnaProcessor::TrackPlot(){ +void SVTClusterAnaProcessor::TrackPlot(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); //FIRST I DO THE PROFILES OF THE NSHARED HITS PLOTS @@ -615,7 +615,7 @@ void ClusterAnaProcessor::TrackPlot(){ return; } -void ClusterAnaProcessor::finalize() { +void SVTClusterAnaProcessor::finalize() { PlotClusterLayers(); PlotClusterLayersNTD(); PlotClusterCharges(); @@ -628,4 +628,4 @@ void ClusterAnaProcessor::finalize() { } return; } -DECLARE_PROCESSOR(ClusterAnaProcessor); +DECLARE_PROCESSOR(SVTClusterAnaProcessor); From e7dc88803306d6463305cb49924da9d6fd5db0ea Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:45:39 -0800 Subject: [PATCH 55/70] Update and rename clusterCompareAna.py to trackHitCompareAna.py --- .../config/{clusterCompareAna.py => trackHitCompareAna.py} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename processors/config/{clusterCompareAna.py => trackHitCompareAna.py} (96%) diff --git a/processors/config/clusterCompareAna.py b/processors/config/trackHitCompareAna.py similarity index 96% rename from processors/config/clusterCompareAna.py rename to processors/config/trackHitCompareAna.py index 074adc887..9f89f6f3f 100644 --- a/processors/config/clusterCompareAna.py +++ b/processors/config/trackHitCompareAna.py @@ -37,7 +37,7 @@ ############################### # Processors # ############################### -cclua = HpstrConf.Processor('cclua','ClusterCompareAnaProcessor') +cclua = HpstrConf.Processor('cclua','TCompareAnaProcessor') cclua.parameters["debug"] = 0 cclua.parameters["layer"] = options.layer cclua.parameters["module"] = options.module From 145d7e3dd0d21362adbb8291adcfc485a31b5b12 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Mon, 12 Feb 2024 17:46:12 -0800 Subject: [PATCH 56/70] Update and rename clusterAna.py to trackHitClusterAna.py --- processors/config/{clusterAna.py => trackHitClusterAna.py} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename processors/config/{clusterAna.py => trackHitClusterAna.py} (96%) diff --git a/processors/config/clusterAna.py b/processors/config/trackHitClusterAna.py similarity index 96% rename from processors/config/clusterAna.py rename to processors/config/trackHitClusterAna.py index c723f9884..69ff2974e 100644 --- a/processors/config/clusterAna.py +++ b/processors/config/trackHitClusterAna.py @@ -37,7 +37,7 @@ ############################### # Processors # ############################### -clua = HpstrConf.Processor('clua','ClusterAnaProcessor') +clua = HpstrConf.Processor('clua','SVTClusterAnaProcessor') clua.parameters["debug"] = 0 clua.parameters["layer"] = options.layer clua.parameters["module"] = options.module From a054ff4a274f3481bb5a0de5107f9f9f8ea94009 Mon Sep 17 00:00:00 2001 From: Sarah Gaiser Date: Mon, 12 Feb 2024 15:59:32 -0800 Subject: [PATCH 57/70] formatting --- processors/config/trackHitClusterAna.py | 14 +- processors/config/trackHitCompareAna.py | 14 +- processors/include/SVTClusterAnaProcessor.h | 56 +- processors/include/SvtRawDataAnaProcessor.h | 65 +- .../include/TrackHitCompareAnaProcessor.h | 71 +- processors/src/SVTClusterAnaProcessor.cxx | 354 +++++----- processors/src/SvtRawDataAnaProcessor.cxx | 473 +++++++------ .../src/TrackHitCompareAnaProcessor.cxx | 653 ++++++++++-------- 8 files changed, 877 insertions(+), 823 deletions(-) diff --git a/processors/config/trackHitClusterAna.py b/processors/config/trackHitClusterAna.py index 69ff2974e..9686eaf9a 100644 --- a/processors/config/trackHitClusterAna.py +++ b/processors/config/trackHitClusterAna.py @@ -4,15 +4,15 @@ from baseConfig import bfield base.parser.add_argument("-L", "--layer", type=int, dest="layer", - help="Layer Under Investigation", metavar="layer",default=-1) + help="Layer Under Investigation", metavar="layer", default=-1) base.parser.add_argument("-M", "--module", type=int, dest="module", - help="Module Under Investigation", metavar="module",default=-1) + help="Module Under Investigation", metavar="module", default=-1) base.parser.add_argument("-MC", "--MC", type=int, dest="isMC", - help="Is the file used generated from Monte Carlo", metavar="module",default=0) + help="Is the file used generated from Monte Carlo", metavar="module", default=0) base.parser.add_argument("-doT", "--doT", type=int, dest="doTrack", - help="We plot the tracking based cluster performance metrics", metavar="doTrack",default=0) + help="We plot the tracking based cluster performance metrics", metavar="doTrack", default=0) base.parser.add_argument("-cut", "--cut", type=float, dest="cut", - help="Momentum Cut for NShared Profile", metavar="cut",default=-1.0) + help="Momentum Cut for NShared Profile", metavar="cut", default=-1.0) options = base.parser.parse_args() @@ -37,7 +37,7 @@ ############################### # Processors # ############################### -clua = HpstrConf.Processor('clua','SVTClusterAnaProcessor') +clua = HpstrConf.Processor('clua', 'SVTClusterAnaProcessor') clua.parameters["debug"] = 0 clua.parameters["layer"] = options.layer clua.parameters["module"] = options.module @@ -50,7 +50,7 @@ p.sequence = sequence -print("processors::clusterAna: The input file is: "+str(root_file)) +print("processors::clusterAna: The input file is: " + str(root_file)) p.input_files = root_file p.output_files = [ana_file] diff --git a/processors/config/trackHitCompareAna.py b/processors/config/trackHitCompareAna.py index 9f89f6f3f..04bbe6929 100644 --- a/processors/config/trackHitCompareAna.py +++ b/processors/config/trackHitCompareAna.py @@ -4,15 +4,15 @@ from baseConfig import bfield base.parser.add_argument("-L", "--layer", type=int, dest="layer", - help="Layer Under Investigation", metavar="layer",default=-1) + help="Layer Under Investigation", metavar="layer", default=-1) base.parser.add_argument("-M", "--module", type=int, dest="module", - help="Module Under Investigation", metavar="module",default=-1) + help="Module Under Investigation", metavar="module", default=-1) base.parser.add_argument("-MC", "--MC", type=int, dest="isMC", - help="Is the file used generated from Monte Carlo", metavar="module",default=0) + help="Is the file used generated from Monte Carlo", metavar="module", default=0) base.parser.add_argument("-doT", "--doT", type=int, dest="doTrack", - help="we plot tracking related cluster performance metrics", metavar="doTrack",default=0) + help="we plot tracking related cluster performance metrics", metavar="doTrack", default=0) base.parser.add_argument("-cut", "--cut", type=float, dest="cut", - help="Momentum Cut for NShared Profile", metavar="cut",default=-1.0) + help="Momentum Cut for NShared Profile", metavar="cut", default=-1.0) options = base.parser.parse_args() @@ -37,7 +37,7 @@ ############################### # Processors # ############################### -cclua = HpstrConf.Processor('cclua','TCompareAnaProcessor') +cclua = HpstrConf.Processor('cclua', 'TCompareAnaProcessor') cclua.parameters["debug"] = 0 cclua.parameters["layer"] = options.layer cclua.parameters["module"] = options.module @@ -50,7 +50,7 @@ p.sequence = sequence -print("processors::clusterAna: The input file is: "+str(root_file)) +print("processors::clusterAna: The input file is: " + str(root_file)) p.input_files = root_file p.output_files = [ana_file] diff --git a/processors/include/SVTClusterAnaProcessor.h b/processors/include/SVTClusterAnaProcessor.h index 27953e6b3..834cceeb4 100644 --- a/processors/include/SVTClusterAnaProcessor.h +++ b/processors/include/SVTClusterAnaProcessor.h @@ -1,7 +1,7 @@ #ifndef __SVTCLUSTER_ANAPROCESSOR_H__ #define __SVTCLUSTER_ANAPROCESSOR_H__ -//HPSTR +// HPSTR #include "HpsEvent.h" #include "RawSvtHit.h" #include "TrackerHit.h" @@ -17,9 +17,8 @@ #include "Track.h" #include "TrackerHit.h" #include "Collections.h" -//#include " -//ROOT +// ROOT #include "Processor.h" #include "TClonesArray.h" #include "TBranch.h" @@ -46,29 +45,27 @@ class SvtClusterAnaProcessor : public Processor { ~SvtClusterAnaProcessor(); /** + * + * This method fills several histograms for each event directed at evaluating clustering performance. For our tracking + * variables we plot z0 vs the number of shared hits with and without a cluster cut (we expect a good reconstruction to have + * have a low number of shared clusters, especially around the z0 vertex and that this would further improve with high p tracks) + * + * To further characterize the clusters we capture basic information: cluster amplitude, time, charge, and strip cluster position + * and distances. We do this for shared and unshared clusters. We perform this for regular or NTD (next to dead) clusters. * - *THIS METHOD FILLS SEVERAL HISTOGRAMS FOR EACH EVENT DIRECTED AT EVALUATING CLUSTERING PERFORMANCE. FOR OUR TRACKING - *VARIABLES WE PLOT Z0 VS THE NUMBER OF SHARED HITS WITH AND WITHOUT A CLUSTER CUT (WE EXPECT A GOOD RECONSTRUCTION TO HAVE - *HAVE A LOW NUMBER OF SHARED CLUSTERS, ESPECIALLY AROUND THE Z0 VERTEX AND THAT THIS WOULD FURTHER IMPROVE WITH HIGH P TRACKS) - * - * - *TO FURTHER CHARACTERIZE THE CLUSTERS WE CAPTURE BASIC INFORMATION: CLUSTER AMPLITUDE, TIME, CHARGE, and STRIP CLUSTER POSITION - *AND DISTANCES. WE DO THIS FOR SHARED AND UNSHARED CLUSTERS. WE PERFORM THIS FOR REGULAR OR NTD (NEXT TO DEAD) CLUSTERS. - * - * */ - + **/ virtual bool process(IEvent* ievent); virtual void initialize(TTree* tree); /** * - *THE REMAINING METHODS (UP TO TRACKPLOT) ALL PLOT STANDARD HISTOGRAMS DESCRIBED IN THE DESCRIPTION TO THE PROCESS METHOD. - *THEY INCLUDE STANDARD FUNCTION CALLS YOU WOULD EXPECT IN A ROOT MACRO AND AFFORD SOME MORE CONTROL THAN A HISTOMANAGER AND - *REGION SELECTOR COMBO. - *FEASIBLE FOR A LIMITED NUMBER OF COLLECTION CUTS. + * The remaining methods (up to TrackPlot) all plot standard histograms described in the description to the process method. + * They include standard function calls you would expect in a ROOT macro and afford some more control than a HistoManager and + * RegionSelector combo. + * Feasible for a limited number of collection cuts. * - * */ + **/ virtual void PlotClusterLayers(); @@ -84,30 +81,27 @@ class SvtClusterAnaProcessor : public Processor { virtual void PlotClusterTimesNTD(); - virtual void TrackPlot1(); + virtual void TrackPlot(); /** * - *THIS METHOD FILLS THE COLLECTION OF DEAD CHANNEL IDS GIVEN AN INPUT FILENAME. REQUIRED FOR NTD PLOTS, BUT LARGELY DISUSED IN THIS PROCESSOR AS OF YET. + * This method fills the collection of dead channels given an input file name. Required for NTD plots, but largely disused in this processor as of yet. * - * */ - + **/ virtual void fillDeads(); /** * - *THIS METHOD GITS THE STRIP COUNT OUT OF ROUGHLY 25000 GIVEN THE FEB AND HYBRID IDS AND THE STRIP NO WRT THESE IDS + * This method gets the strip count out of roughly 25000 given the FEB and hybrid IDs and the strip number with respect to these IDs. * - * */ - + **/ virtual int GetStrip(int feb, int hyb,int strip); /** * - *THE FINALIZE METHOD CALLS ALL THE PLOTTING MACROS ABOVE. THEY ARE CREATED INTO PNGS INTO THE REPOSITORY THE PROCESSOR IS CALLED IN. - * - * */ - + * The finalize method calls all the plotting macros above. They are created into PNGs into the repository the processor is called in. + * + **/ virtual void finalize(); virtual void configure(const ParameterSet& parameters); @@ -153,7 +147,7 @@ class SvtClusterAnaProcessor : public Processor { TH1F* timesOnTrkNTD_; TH1F* timesOffTrkNTD_; - //TRACKING RELATED VARIABLES + // TRACKING RELATED VARIABLES TH2F* Z0VNShare2Hist_; TH2F* Z0VNShare2HistCut_; @@ -173,8 +167,6 @@ class SvtClusterAnaProcessor : public Processor { std::vector * svtraw_{}; std::vector * tracks_{}; - - //std::string anaName_{"ClusterAna"}; int debug_{0}; int isMC_{0}; std::string badchann_{""}; diff --git a/processors/include/SvtRawDataAnaProcessor.h b/processors/include/SvtRawDataAnaProcessor.h index 2cd0fd59c..112272702 100644 --- a/processors/include/SvtRawDataAnaProcessor.h +++ b/processors/include/SvtRawDataAnaProcessor.h @@ -1,7 +1,7 @@ #ifndef __RAWSVTHIT_ANAPROCESSOR_H__ #define __RAWSVTHIT_ANAPROCESSOR_H__ -//HPSTR +// HPSTR #include "HpsEvent.h" #include "RawSvtHit.h" #include "RawSvtHitHistos.h" @@ -16,9 +16,7 @@ #include "Track.h" #include "TrackerHit.h" -//#include " -//ROOT - +// ROOT #include "Processor.h" #include "TClonesArray.h" #include "TBranch.h" @@ -43,61 +41,55 @@ class SvtRawDataAnaProcessor : public Processor { ~SvtRawDataAnaProcessor(); - /* - * - *RUNS OVER THE REGION SELECTORS AND CHECKS IF AN EVENT PASSES A SELECTION JSON AND FILLS A RAWSVTHITHISTO - IF DO SAMPLE IS ON, IT RUNS SAMPLING. + /** * + * Runs over the region selectors and checks if an event passes a selection json and fills a rawsvthithisto + * if do sample is on, it runs sampling. * - */ + **/ virtual bool process(IEvent* ievent); - /* - * - *PROCESS INITIALIZER. READS IN THE OFFLINE BASELINES INTO LOCAL BASELINE FILES, READs in the PULSE SHAPES, and FINALLLY - ESTABLISHES REGIONS WHICH ARE USED ALONG WITH THE REGION SELECTOR CLASS AND CUTS IN ANALYSIS/SELECTION/SVT TO SELECT ON - EVENTS FOR WHICH HISTOGRAMS IN RAWSVTHISTO IS FILLED. + /** * + * Process initializer. Reads in the offline baselines into local baseline files, reads in the pulse shapes, and finally + * establishes regions which are used along with the region selector class and cuts in analysis/selection/svt to select on + * events for which histograms in rawsvthisto is filled. * - */ - + **/ virtual void initialize(TTree* tree); virtual void sample(RawSvtHit* thisHit, std::string word, IEvent* ievent, long t,int i); - /* + /** * - *FOUR POLE PULSE FUNCTION AND THE SUM OF TWO OF THEM WITH BASELINES BORROWED FROM ALIC + * Four pole pulse function and the sum of two of them with baselines borrowed from Alic * - */ - + **/ virtual TF1* fourPoleFitFunction(std::string word, int caser); /** * - *THIS METHOD IS IMPLEMENTED BECAUSE C++ std:of METHOD WHICH CONVERTS STRINGS - *TO FLOATS IS NOT WORKING. WE NEED THIS TO READ IN OFFLINE BASELINES AND CHARACTERISTIC TIMES. + * This method is implemented because C++ std:of method which converts strings + * to floats is not working. We need this to read in offline baselines and characteristic times. * - * - * */ - + **/ virtual float str_to_float(std::string word); float reverseEngineerTime(float ti, long t); - /* - *FILLS IN HISTOGRAMS + /** + * + * Fills in histograms * - */ - + **/ virtual void finalize(); virtual void configure(const ParameterSet& parameters); private: - //Containers to hold histogrammer info + // Containers to hold histogrammer info RawSvtHitHistos* histos{nullptr}; std::string histCfgFilename_; Float_t TimeRef_; @@ -121,14 +113,8 @@ class SvtRawDataAnaProcessor : public Processor { TBranch* bPart_{nullptr}; TBranch* bTrk_{nullptr}; TBranch* bClusters_{nullptr}; - TBranch* bevH_; - /* - TTree *HitEff_; - //TBranch* bL1_{nullptr}; - int L1_; - bool doHitEff_{false}; - */ + std::vector * svtHits_{}; VTPData * vtpBank_; TSData * tsBank_; @@ -136,8 +122,7 @@ class SvtRawDataAnaProcessor : public Processor { std::vector* Trk_{}; std::vector* Part_{}; std::vector* Clusters_{}; - - //std::vector Trk_{}; + EventHeader * evH_; std::string anaName_{"rawSvtHitAna"}; @@ -151,7 +136,7 @@ class SvtRawDataAnaProcessor : public Processor { std::string timeProfiles_; int tphase_{6}; - //Debug Level + // Debug Level int debug_{0}; }; diff --git a/processors/include/TrackHitCompareAnaProcessor.h b/processors/include/TrackHitCompareAnaProcessor.h index ce10c3054..5caaa4db6 100644 --- a/processors/include/TrackHitCompareAnaProcessor.h +++ b/processors/include/TrackHitCompareAnaProcessor.h @@ -1,7 +1,7 @@ #ifndef __TRACKHITCOMPARE_ANAPROCESSOR_H__ #define __TRACKHITCOMPARE_ANAPROCESSOR_H__ -//HPSTR +// HPSTR #include "HpsEvent.h" #include "RawSvtHit.h" #include "TrackerHit.h" @@ -17,9 +17,8 @@ #include "Track.h" #include "TrackerHit.h" #include "Collections.h" -//#include " -//ROOT +// ROOT #include "Processor.h" #include "TClonesArray.h" #include "TBranch.h" @@ -47,33 +46,31 @@ class TrackHitCompareAnaProcessor : public Processor { /** * - *THIS METHOD FILLS SEVERAL HISTOGRAMS FOR EACH EVENT DIRECTED AT EVALUATING CLUSTERING PERFORMANCE. FOR OUR TRACKING - *VARIABLES WE PLOT Z0 VS THE NUMBER OF SHARED HITS WITH AND WITHOUT A CLUSTER CUT (WE EXPECT A GOOD RECONSTRUCTION TO HAVE - *HAVE A LOW NUMBER OF SHARED CLUSTERS, ESPECIALLY AROUND THE Z0 VERTEX AND THAT THIS WOULD FURTHER IMPROVE WITH HIGH P TRACKS) - *WE ALSO DIRECTLY COMPARE THE REGULAR AND TRANSVERSE MOMENTUM DISTRIBUTIONS FOR THE TWO METHODS. - * - *TO FURTHER CHARACTERIZE THE CLUSTERS WE CAPTURE BASIC INFORMATION: CLUSTER AMPLITUDE, TIME, CHARGE, and STRIP CLUSTER POSITION - *AND DISTANCES. WE DO THIS FOR SHARED AND UNSHARED CLUSTERS. WE LARGELY IGNORE NTD, OR NEXT TO DEAD, ANALYSIS IN THIS PROCESSOR. - * - *THIS PROCESSOR IS UNDENIABLY EXTREMELY SIMILAR TO CLUSTERANAPROCESSOR, HAVING BEEN ITS OFFSPRING. THE MAIN DISTINCTION IS THAT - *THIS PROCESSOR IMPLEMENTS AN IDENTITY TRACKER (ident_) WHICH, ATM, IS IMPLEMENTED TO DETECT WHETHER AN EVENT IS IN TYPE 1 OR TYPE2 - *ALONG WITH A SHORT MACRO WHICH ASSOCIATES TO DIFFERENTLY RECONSTRUCTED ROOT FILES A IDENTIFICATION MONICER, THIS ALLOWS FOR QUICK - *DIRECT COMPARISON OF TWO MEANS OF RECONSTRUCTION. - * - * */ - + * This method fills several histograms for each event directed at evaluating clustering performance. For our tracking + * variables we plot z0 vs the number of shared hits with and without a cluster cut (we expect a good reconstruction to have + * have a low number of shared clusters, especially around the z0 vertex and that this would further improve with high p tracks) + * We also directly compare the regular and transverse momentum distributions for the two methods. + * + * To further characterize the clusters we capture basic information: cluster amplitude, time, charge, and strip cluster position + * and distances. We do this for shared and unshared clusters. We perform this for regular or NTD (next to dead) clusters. + * + * This processor is undeniably extremely similar to ClusterAnaProcessor, having been its offspring. The main distinction is that + * this processor implements an identity tracker (ident_) which, atm, is implemented to detect whether an event is in type 1 or type 2 + * along with a short macro which associates to differently reconstructed root files a identification monicer, this allows for quick + * direct comparison of two means of reconstruction. + * + **/ virtual bool process(IEvent* ievent); virtual void initialize(TTree* tree); /** * - *THE REMAINING METHODS (UP TO TRACKPLOT) ALL PLOT STANDARD HISTOGRAMS DESCRIBED IN THE DESCRIPTION TO THE PROCESS METHOD. - *THEY INCLUDE STANDARD FUNCTION CALLS YOU WOULD EXPECT IN A ROOT MACRO AND AFFORD SOME MORE CONTROL THAN A HISTOMANAGER AND - *REGION SELECTOR COMBO. - *FEASIBLE FOR A LIMITED NUMBER OF COLLECTION CUTS. + * The remaining methods (up to TrackPlot) all plot standard histograms described in the description to the process method. + * They include standard function calls you would expect in a root macro and afford some more control than a histomanager and + * region selector combo. * - * */ + **/ virtual void PlotClusterLayers(); @@ -89,33 +86,30 @@ class TrackHitCompareAnaProcessor : public Processor { /** * - *THIS METHOD FILLS THE COLLECTION OF DEAD CHANNEL IDS GIVEN AN INPUT FILENAME. REQUIRED FOR NTD PLOTS, BUT LARGELY DISUSED IN THIS PROCESSOR AS OF YET. + * This method fills the collection of dead channel ids given an input filename. Required for NTD plots, but largely disused in this processor as of yet. * - * */ - + **/ virtual void fillDeads(); /** * - *THIS METHOD GITS THE STRIP COUNT OUT OF ROUGHLY 25000 GIVEN THE FEB AND HYBRID IDS AND THE STRIP NO WRT THESE IDS + * This method gets the strip count out of roughly 25000 given the feb and hybrid ids and the strip no wrt these IDs * - * */ - + **/ virtual int GetStrip(int feb, int hyb,int strip); /** * - *THE FINALIZE METHOD CALLS ALL THE PLOTTING MACROS ABOVE. THEY ARE CREATED INTO PNGS INTO THE REPOSITORY THE PROCESSOR IS CALLED IN. + * The finalize method calls all the plotting macros above. They are created into pngs into the repository the processor is called in. * - * */ - + **/ virtual void finalize(); virtual void configure(const ParameterSet& parameters); private: - //Containers to hold histogrammer info + // Containers to hold histogrammer info ModuleMapper * mmapper_; TTree* tree_; @@ -128,8 +122,7 @@ class TrackHitCompareAnaProcessor : public Processor { int layer_{-1}; int module_{-1}; - //FOR THE FIRST FILE - + // FOR THE FIRST FILE TH1F* layers1_; TH1F* layersOnTrk1_; TH1F* layersOffTrk1_; @@ -156,8 +149,7 @@ class TrackHitCompareAnaProcessor : public Processor { TH1F* timesOnTrkNTD1_; TH1F* timesOffTrkNTD1_; - //FOR THE SECOND FILE - + // FOR THE SECOND FILE TH1F* layers2_; TH1F* layersOnTrk2_; TH1F* layersOffTrk2_; @@ -184,8 +176,7 @@ class TrackHitCompareAnaProcessor : public Processor { TH1F* timesOnTrkNTD2_; TH1F* timesOffTrkNTD2_; - //TRACKING RELATED VARIABLES - + // TRACKING RELATED VARIABLES TH2F* Z0VNShare2Hist1_; TH2F* Z0VNShare2HistCut1_; TH1F* SharedAmplitudes1_; @@ -223,8 +214,6 @@ class TrackHitCompareAnaProcessor : public Processor { std::vector * svtraw_{}; std::vector * tracks_{}; - - //std::string anaName_{"ClusterAna"}; int debug_{0}; int isMC_{0}; float ident_{1.0}; diff --git a/processors/src/SVTClusterAnaProcessor.cxx b/processors/src/SVTClusterAnaProcessor.cxx index f1d7a6d09..a985636c6 100644 --- a/processors/src/SVTClusterAnaProcessor.cxx +++ b/processors/src/SVTClusterAnaProcessor.cxx @@ -23,8 +23,7 @@ void SVTClusterAnaProcessor::configure(const ParameterSet& parameters) { isMC_ = parameters.getInteger("isMC"); doingTracks_ = (parameters.getInteger("doTrack")==1); pcut_ = (float)parameters.getDouble("cut"); - badchann_ = parameters.getString("badchannels"); - //anaName_ = parameters.getString("anaName"); + badchann_ = parameters.getString("badchannels"); } catch (std::runtime_error& error) { @@ -35,89 +34,89 @@ void SVTClusterAnaProcessor::configure(const ParameterSet& parameters) { void SVTClusterAnaProcessor::initialize(TTree* tree) { fillDeads(); - tree_= tree; + tree_ = tree; - if(isMC_==1){ - layers_=new TH1F("layers","MC Strip Width for All Clusters",12,0.0,12.0); - layersOnTrk_=new TH1F("layersOnTrk","MC Strip Width for Clusters on Track",12,0.0,12.0); - layersOffTrk_=new TH1F("layersOffTrk","MC Strip Width for Clusters off Track",12,0.0,12.0); - charges_=new TH1F("charges","MC Charge Distribution for All Clusters",1000,0.0,0.000016); - chargesOnTrk_=new TH1F("chargesOnTrk","MC Charge Distribution for On Track",1000,0.0,.000016); - chargesOffTrk_=new TH1F("chargesOffTrk","MC Charge Distribution for Off Track",1000,0.0,0.000016); - - layersNTD_=new TH1F("layersNTD","MC Strip Width for All Clusters",12,0.0,12.0); - layersOnTrkNTD_=new TH1F("layersOnTrkNTD","MC Strip Width for Clusters on Track",12,0.0,12.0); - layersOffTrkNTD_=new TH1F("layersOffTrkNTD","MC Strip Width for Clusters off Track",12,0.0,12.0); - chargesNTD_=new TH1F("chargesNTD","MC Charge Distribution for All Clusters",1000,0.0,0.000016); - chargesOnTrkNTD_=new TH1F("chargesOnTrkNTD","MC Charge Distribution for On Track",1000,0.0,.000016); - chargesOffTrkNTD_=new TH1F("chargesOffTrkNTD","MC Charge Distribution for Off Track",1000,0.0,0.000016); - - positions_=new TH1F("Positions","MC Location of Cluster Hit;Layer;Hits",14,0.0,14.0); - positionsOnTrk_=new TH1F("PositionsOnTrk","MC Location of Cluster Hit for On Track",14,0.0,14.0); - ClusDistances_=new TH1F("Minimum Cluster Difference","MC Minimum Distance Between Clusters",14,0.0,14.0); - ClusDistancesNTD_=new TH1F("Minimum Cluster Difference","MC Minimum Distance Between Clusters",14,0.0,14.0); - - times_=new TH1F("Times","MC Time of Cluster Hit",1000,-60.0,60.0); - timesOnTrk_=new TH1F("TimesOnTrk","MC Time of On Track Cluster Hit",1000,-60.0,60.0); - timesOffTrk_=new TH1F("TimesOffTrk","MC Time of Off Cluster Hit",1000,-60.0,60.0); - timesNTD_=new TH1F("TimesNTD","MC Time of Cluster Hit NTD",1000,-60.0,60.0); - timesOnTrkNTD_=new TH1F("TimesOnTrkNTD","MC Time of On Track Cluster Hit NTD",1000,-60.0,60.0); - timesOffTrkNTD_=new TH1F("TimesOffTrkNTD","MC Time of Off Cluster Hit NTD",1000,-60.0,60.0); - - tree_->SetBranchAddress("SiClusters",&Clusters_,&bClusters_); - tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); - tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); + if (isMC_==1){ + layers_ = new TH1F("layers", "MC Strip Width for All Clusters", 12, 0.0, 12.0); + layersOnTrk_ = new TH1F("layersOnTrk", "MC Strip Width for Clusters on Track", 12, 0.0, 12.0); + layersOffTrk_ = new TH1F("layersOffTrk", "MC Strip Width for Clusters off Track", 12, 0.0, 12.0); + charges_ = new TH1F("charges", "MC Charge Distribution for All Clusters", 1000, 0.0, 0.000016); + chargesOnTrk_ = new TH1F("chargesOnTrk", "MC Charge Distribution for On Track", 1000, 0.0, 0.000016); + chargesOffTrk_ = new TH1F("chargesOffTrk", "MC Charge Distribution for Off Track", 1000, 0.0, 0.000016); + + layersNTD_ = new TH1F("layersNTD", "MC Strip Width for All Clusters", 12, 0.0, 12.0); + layersOnTrkNTD_ = new TH1F("layersOnTrkNTD", "MC Strip Width for Clusters on Track", 12, 0.0, 12.0); + layersOffTrkNTD_ = new TH1F("layersOffTrkNTD", "MC Strip Width for Clusters off Track", 12, 0.0, 12.0); + chargesNTD_ = new TH1F("chargesNTD", "MC Charge Distribution for All Clusters", 1000, 0.0, 0.000016); + chargesOnTrkNTD_ = new TH1F("chargesOnTrkNTD", "MC Charge Distribution for On Track", 1000, 0.0, .000016); + chargesOffTrkNTD_ = new TH1F("chargesOffTrkNTD", "MC Charge Distribution for Off Track", 1000, 0.0, 0.000016); + + positions_ = new TH1F("Positions", "MC Location of Cluster Hit;Layer;Hits", 14, 0.0, 14.0); + positionsOnTrk_ = new TH1F("PositionsOnTrk", "MC Location of Cluster Hit for On Track", 14, 0.0, 14.0); + ClusDistances_ = new TH1F("Minimum Cluster Difference", "MC Minimum Distance Between Clusters", 14, 0.0, 14.0); + ClusDistancesNTD_ = new TH1F("Minimum Cluster Difference", "MC Minimum Distance Between Clusters", 14, 0.0, 14.0); + + times_ = new TH1F("Times", "MC Time of Cluster Hit", 1000, -60.0, 60.0); + timesOnTrk_ = new TH1F("TimesOnTrk", "MC Time of On Track Cluster Hit", 1000, -60.0, 60.0); + timesOffTrk_ = new TH1F("TimesOffTrk", "MC Time of Off Cluster Hit", 1000, -60.0, 60.0); + timesNTD_ = new TH1F("TimesNTD", "MC Time of Cluster Hit NTD", 1000, -60.0, 60.0); + timesOnTrkNTD_ = new TH1F("TimesOnTrkNTD", "MC Time of On Track Cluster Hit NTD", 1000, -60.0, 60.0); + timesOffTrkNTD_ = new TH1F("TimesOffTrkNTD", "MC Time of Off Cluster Hit NTD", 1000, -60.0, 60.0); + + tree_->SetBranchAddress("SiClusters", &Clusters_, &bClusters_); + tree_->SetBranchAddress("SiClustersOnTrack_KF", &ClustersKF_, &bClustersKF_); + tree_->SetBranchAddress("SVTRawTrackerHits", &svtraw_, &bsvtraw_); return; } - layers_=new TH1F("layers","Strip Width for All Clusters",12,0.0,12.0); - layersOnTrk_=new TH1F("layersOnTrk","Strip Width for Clusters on Track",12,0.0,12.0); - layersOffTrk_=new TH1F("layersOffTrk","Strip Width for Clusters off Track",12,0.0,12.0); - charges_=new TH1F("charges","Charge Distribution for All Clusters",1000,0.0,0.000016); - chargesOnTrk_=new TH1F("chargesOnTrk","Charge Distribution for On Track",1000,0.0,.000016); - chargesOffTrk_=new TH1F("chargesOffTrk","Charge Distribution for Off Track",1000,0.0,0.000016); - - layersNTD_=new TH1F("layersNTD","Strip Width for All Clusters",12,0.0,12.0); - layersOnTrkNTD_=new TH1F("layersOnTrkNTD","Strip Width for Clusters on Track",12,0.0,12.0); - layersOffTrkNTD_=new TH1F("layersOffTrkNTD","Strip Width for Clusters off Track",12,0.0,12.0); - chargesNTD_=new TH1F("chargesNTD","Charge Distribution for All Clusters",1000,0.0,0.000016); - chargesOnTrkNTD_=new TH1F("chargesOnTrkNTD","Charge Distribution for On Track",1000,0.0,.000016); - chargesOffTrkNTD_=new TH1F("chargesOffTrkNTD","Charge Distribution for Off Track",1000,0.0,0.000016); - - positions_=new TH1F("Positions","Location of Cluster Hit;Layer;Hits",14,0.0,14.0); - positionsOnTrk_=new TH1F("PositionsOnTrk","Location of Cluster Hit for On Track",14,0.0,14.0); - ClusDistances_=new TH1F("Minimum Cluster Difference","Minimum Distance Between Clusters",14,0.0,14.0); - ClusDistancesNTD_=new TH1F("Minimum Cluster Difference","Minimum Distance Between Clusters",14,0.0,14.0); - - times_=new TH1F("Times","Time of Cluster Hit",1000,-60.0,60.0); - timesOnTrk_=new TH1F("TimesOnTrk","Time of On Track Cluster Hit",1000,-60.0,60.0); - timesOffTrk_=new TH1F("TimesOffTrk","Time of Off Cluster Hit",1000,-60.0,60.0); - timesNTD_=new TH1F("TimesNTD","Time of Cluster Hit NTD",1000,-60.0,60.0); - timesOnTrkNTD_=new TH1F("TimesOnTrkNTD","Time of On Track Cluster Hit NTD",1000,-60.0,60.0); - timesOffTrkNTD_=new TH1F("TimesOffTrkNTD","Time of Off Cluster Hit NTD",1000,-60.0,60.0); - if(doingTracks_){ - Z0VNShare2Hist_= new TH2F("Z0VNShare2Hist","Z0 versus Number of Shared Hits No Cut",100,0,3,8,0,8); - Z0VNShare2HistCut_= new TH2F("Z0VNShare2HistCut","Z0 versus Number of Shared Hits Momentum Cut",100,0,3,8,0,8); - SharedAmplitudes_= new TH1F("SharedAmplitudes","The Amplitudes of Clusters Shared Between Tracks",1000,0.0,0.000016); - UnSharedAmplitudes_= new TH1F("UnSharedAmplitudes","The Amplitudes of Clusters Not Shared Between Tracks",1000,0.0,0.000016); - SharedTimes_= new TH1F("SharedTimes","The Times of Clusters Shared Between Tracks",1000,-60.0,60.0); - UnSharedTimes_= new TH1F("UnSharedTimes","The Times of Clusters Not Shared Between Tracks",1000,-60.0,60.0); + layers_ = new TH1F("layers", "Strip Width for All Clusters", 12, 0.0, 12.0); + layersOnTrk_ = new TH1F("layersOnTrk", "Strip Width for Clusters on Track", 12, 0.0, 12.0); + layersOffTrk_ = new TH1F("layersOffTrk", "Strip Width for Clusters off Track", 12, 0.0, 12.0); + charges_ = new TH1F("charges", "Charge Distribution for All Clusters", 1000, 0.0, 0.000016); + chargesOnTrk_ = new TH1F("chargesOnTrk", "Charge Distribution for On Track", 1000, 0.0, .000016); + chargesOffTrk_ = new TH1F("chargesOffTrk", "Charge Distribution for Off Track", 1000, 0.0, 0.000016); + + layersNTD_ = new TH1F("layersNTD", "Strip Width for All Clusters", 12, 0.0, 12.0); + layersOnTrkNTD_ = new TH1F("layersOnTrkNTD", "Strip Width for Clusters on Track", 12, 0.0, 12.0); + layersOffTrkNTD_ = new TH1F("layersOffTrkNTD", "Strip Width for Clusters off Track", 12, 0.0, 12.0); + chargesNTD_ = new TH1F("chargesNTD", "Charge Distribution for All Clusters", 1000, 0.0, 0.000016); + chargesOnTrkNTD_ = new TH1F("chargesOnTrkNTD", "Charge Distribution for On Track", 1000, 0.0, .000016); + chargesOffTrkNTD_ = new TH1F("chargesOffTrkNTD", "Charge Distribution for Off Track", 1000, 0.0, 0.000016); + + positions_ = new TH1F("Positions", "Location of Cluster Hit;Layer;Hits", 14, 0.0, 14.0); + positionsOnTrk_ = new TH1F("PositionsOnTrk", "Location of Cluster Hit for On Track", 14, 0.0, 14.0); + ClusDistances_ = new TH1F("Minimum Cluster Difference", "Minimum Distance Between Clusters", 14, 0.0, 14.0); + ClusDistancesNTD_ = new TH1F("Minimum Cluster Difference", "Minimum Distance Between Clusters", 14, 0.0, 14.0); + + times_ = new TH1F("Times", "Time of Cluster Hit", 1000, -60.0, 60.0); + timesOnTrk_ = new TH1F("TimesOnTrk", "Time of On Track Cluster Hit", 1000, -60.0, 60.0); + timesOffTrk_ = new TH1F("TimesOffTrk", "Time of Off Cluster Hit", 1000, -60.0, 60.0); + timesNTD_ = new TH1F("TimesNTD", "Time of Cluster Hit NTD", 1000, -60.0, 60.0); + timesOnTrkNTD_ = new TH1F("TimesOnTrkNTD", "Time of On Track Cluster Hit NTD", 1000, -60.0, 60.0); + timesOffTrkNTD_ = new TH1F("TimesOffTrkNTD", "Time of Off Cluster Hit NTD", 1000, -60.0, 60.0); + if (doingTracks_){ + Z0VNShare2Hist_ = new TH2F("Z0VNShare2Hist", "Z0 versus Number of Shared Hits No Cut", 100, 0, 3, 8, 0, 8); + Z0VNShare2HistCut_ = new TH2F("Z0VNShare2HistCut", "Z0 versus Number of Shared Hits Momentum Cut", 100, 0, 3, 8, 0, 8); + SharedAmplitudes_ = new TH1F("SharedAmplitudes", "The Amplitudes of Clusters Shared Between Tracks", 1000, 0.0, 0.000016); + UnSharedAmplitudes_ = new TH1F("UnSharedAmplitudes", "The Amplitudes of Clusters Not Shared Between Tracks", 1000, 0.0, 0.000016); + SharedTimes_ = new TH1F("SharedTimes", "The Times of Clusters Shared Between Tracks", 1000, -60.0, 60.0); + UnSharedTimes_ = new TH1F("UnSharedTimes", "The Times of Clusters Not Shared Between Tracks", 1000, -60.0, 60.0); } - tree_->SetBranchAddress("SiClusters",&Clusters_,&bClusters_); - tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); - tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); - if(doingTracks_){ - tree_->SetBranchAddress("KalmanFullTracks",&tracks_,&btracks_); + tree_->SetBranchAddress("SiClusters", &Clusters_, &bClusters_); + tree_->SetBranchAddress("SiClustersOnTrack_KF", &ClustersKF_, &bClustersKF_); + tree_->SetBranchAddress("SVTRawTrackerHits", &svtraw_, &bsvtraw_); + if (doingTracks_){ + tree_->SetBranchAddress("KalmanFullTracks", &tracks_, &btracks_); } } bool SVTClusterAnaProcessor::process(IEvent* ievent) { - if(doingTracks_){ - for(int i = 0;isize();i++){ + if (doingTracks_){ + for (int i = 0; isize(); i++){ Track* track = tracks_->at(i); - if(track->getTrackTime()*track->getTrackTime()<100.0){ - Z0VNShare2Hist_->Fill(track->getZ0Err(),track->getNShared()); - if(track->getP()Fill(track->getZ0Err(),track->getNShared()); + if (track->getTrackTime()*track->getTrackTime() < 100.0){ + Z0VNShare2Hist_->Fill(track->getZ0Err(), track->getNShared()); + if (track->getP() < pcut_){ + Z0VNShare2HistCut_->Fill(track->getZ0Err(), track->getNShared()); } } } @@ -129,107 +128,106 @@ bool SVTClusterAnaProcessor::process(IEvent* ievent) { RawSvtHit * seed = (RawSvtHit*)(clu->getRawHits().At(0)); - layc=clu->getLayer(); - modc=seed->getModule(); + layc = clu->getLayer(); + modc = seed->getModule(); - if(doingTracks_){ - bool isShared = false;int increment = 0; - for(int i = 0;isize();i++){ + if (doingTracks_){ + bool isShared = false; + int increment = 0; + for (int i = 0; isize(); i++){ Track* track = tracks_->at(i); - for(int j = 0; jgetSvtHits().GetEntries();j++){ + for (int j = 0; jgetSvtHits().GetEntries(); j++){ TrackerHit * test = (TrackerHit *)(track->getSvtHits().At(j)); - if(clu->getTime()==test->getTime()){ - increment+=1; + if (clu->getTime()==test->getTime()){ + increment += 1; } } } - if(increment>1){ - isShared=true; + if (increment > 1){ + isShared = true; } - if(increment>0){ + if (increment > 0){ bool general = ((layer_==-1)||(module_==-1)); - if(((layc==layer_)&&(modc==module_))||(general)){ - if(isShared){ + if (((layc==layer_)&&(modc==module_))||(general)){ + if (isShared){ SharedAmplitudes_->Fill(clu->getCharge()); SharedTimes_->Fill(clu->getTime()); - }else{ + } else { UnSharedAmplitudes_->Fill(clu->getCharge()); UnSharedTimes_->Fill(clu->getTime()); } } } } - - + float seedStrip = (float)(seed->getStrip()); float nLayers = (float)(clu->getRawHits().GetEntries()); float ncharges = (float)(clu->getCharge()); float ntimes = (float)(clu->getTime()); bool onTrk = false; bool NTD = false; - for(unsigned int j = 0; j < ClustersKF_->size(); j++){ - if(clu->getID()==(ClustersKF_->at(j)->getID())){ + for (unsigned int j = 0; j < ClustersKF_->size(); j++){ + if (clu->getID()==(ClustersKF_->at(j)->getID())){ onTrk = true; } } - - std::string input = "ly"+std::to_string(layc+1)+"_m"+std::to_string(modc); + std::string input = "ly" + std::to_string(layc+1) + "_m" + std::to_string(modc); std::string helper = mmapper_->getHwFromSw(input); - int feb=std::stoi(helper.substr(1,1)); - int hyb=std::stoi(helper.substr(3,1)); + int feb = std::stoi(helper.substr(1, 1)); + int hyb = std::stoi(helper.substr(3, 1)); - int channelL=seedStrip-1; - int channelR=seedStrip+1; - if(channelL>=0){ - NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelL)]==1); + int channelL = seedStrip-1; + int channelR = seedStrip+1; + if (channelL >= 0){ + NTD = (NTD)||(Deads_[GetStrip(feb, hyb, channelL)]==1); } - if(((feb<=1)&&(channelR<=511))||((feb>1)&&(channelR<=639))){ - NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelR)]==1); + if (((feb<=1)&&(channelR<=511))||((feb>1)&&(channelR<=639))){ + NTD = (NTD)||(Deads_[GetStrip(feb, hyb, channelR)]==1); } bool general = ((layer_==-1)||(module_==-1)); - if(((layc==layer_)&&(modc==module_))||(general)){ - //Now is the part where I fill the cluster distance histogram. - float Dist=69420; + if (((layc==layer_)&&(modc==module_))||(general)){ + // Now is the part where I fill the cluster distance histogram. + float dist = 69420; for(int p = 0; p < Clusters_->size(); p++){ - if(p==i){continue;} + if (p==i) { continue; } TrackerHit * clu2 = Clusters_->at(p); RawSvtHit * seed2 = (RawSvtHit*)(clu2->getRawHits().At(0)); - float layc2=clu->getLayer(); - float modc2=seed->getModule(); - if((not(layc2==layc))or(not(modc2==modc))){continue;} - float dist = ((float)(seed2->getStrip()))-seedStrip; - if(dist<0){dist*=-1.0;} - if(distgetLayer(); + float modc2 = seed->getModule(); + if ((!(layc2==layc))||(!(modc2==modc))) { continue; } + float new_dist = ((float)(seed2->getStrip())) - seedStrip; + if (new_dist < 0) { new_dist *= -1.0; } + if (new_dist < dist) { dist = new_dist; } } - if(Dist<69420){ - ClusDistances_->Fill(Dist); - if(NTD){ClusDistancesNTD_->Fill(Dist);} + if (dist < 69420){ + ClusDistances_->Fill(dist); + if (NTD) {ClusDistancesNTD_->Fill(dist);} } layers_->Fill(nLayers); charges_->Fill(ncharges); positions_->Fill(clu->getLayer()); times_->Fill(ntimes); - if(onTrk){ + if (onTrk) { layersOnTrk_->Fill(nLayers); chargesOnTrk_->Fill(ncharges); timesOnTrk_->Fill(ntimes); - }else{ + } else { layersOffTrk_->Fill(nLayers); chargesOffTrk_->Fill(ncharges); timesOffTrk_->Fill(ntimes); } - if(NTD){ + if (NTD) { layersNTD_->Fill(nLayers); chargesNTD_->Fill(ncharges); positionsOnTrk_->Fill(clu->getLayer()); timesNTD_->Fill(ntimes); - if(onTrk){ + if (onTrk) { layersOnTrkNTD_->Fill(nLayers); chargesOnTrkNTD_->Fill(ncharges); timesOnTrkNTD_->Fill(ntimes); - }else{ + } else { layersOffTrkNTD_->Fill(nLayers); chargesOffTrkNTD_->Fill(ncharges); timesOffTrkNTD_->Fill(ntimes); @@ -241,30 +239,30 @@ bool SVTClusterAnaProcessor::process(IEvent* ievent) { } void SVTClusterAnaProcessor::fillDeads(){ - for(int i = 0;i<24576;i++){ - Deads_[i]=0.0; + for(int i = 0; i<24576; i++){ + Deads_[i] = 0.0; } std::string FILENAME=badchann_; std::ifstream file(FILENAME.c_str()); std::string line; - std::getline(file,line); + std::getline(file, line); while (std::getline(file, line)) { int value = std::atoi(line.c_str()); - Deads_[value]=1.0; + Deads_[value] = 1.0; } file.close(); return; } -int SVTClusterAnaProcessor::GetStrip(int feb,int hyb,int strip){ - int BigCount = 0; - if(feb<=1){ - BigCount+=feb*2048+hyb*512+strip; - }else{ - BigCount+=4096; - BigCount+=(feb-2)*2560+hyb*640+strip; +int SVTClusterAnaProcessor::GetStrip(int feb, int hyb, int strip){ + int count = 0; + if (feb <= 1){ + count += feb*2048 + hyb*512 + strip; + } else { + count += 4096; + count += (feb-2)*2560 + hyb*640 + strip; } - return BigCount; + return count; } void SVTClusterAnaProcessor::PlotClusterLayers(){ @@ -278,7 +276,7 @@ void SVTClusterAnaProcessor::PlotClusterLayers(){ layersOffTrk_->GetXaxis()->SetTitle("Width (strip)"); layersOffTrk_->GetYaxis()->SetTitle("Hits"); - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle("Layers for All Clusters"); layers_->Draw("e"); c1->SaveAs("allClusters.png"); @@ -295,12 +293,12 @@ void SVTClusterAnaProcessor::PlotClusterLayers(){ c1->Clear(); layers_->SetTitle("Cluster Strip Width for all Cluster Cuts"); - auto legend = new TLegend(0.3,0.8,.68,.9); + auto legend = new TLegend(0.3, 0.8, .68, .9); layers_->SetLineColor(kCyan); layersOnTrk_->SetLineColor(kGreen); - legend->AddEntry(layers_,"Layers"); - legend->AddEntry(layersOnTrk_,"Layers On Track"); - legend->AddEntry(layersOffTrk_,"Layers Off Track"); + legend->AddEntry(layers_, "Layers"); + legend->AddEntry(layersOnTrk_, "Layers On Track"); + legend->AddEntry(layersOffTrk_, "Layers Off Track"); layers_->Draw("e"); layersOnTrk_->Draw("same e"); layersOffTrk_->Draw("same e"); @@ -322,7 +320,7 @@ void SVTClusterAnaProcessor::PlotClusterCharges(){ chargesOnTrk_->GetXaxis()->SetTitle("Charge"); chargesOnTrk_->GetYaxis()->SetTitle("Hits"); - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle("Charges for All Clusters"); charges_->Draw("e"); c1->SaveAs("allClustersCharge.png"); @@ -339,12 +337,12 @@ void SVTClusterAnaProcessor::PlotClusterCharges(){ c1->Clear(); layers_->SetTitle("Putting all Charges Together"); - auto legend = new TLegend(0.3,0.8,.68,.9); + auto legend = new TLegend(0.3, 0.8, .68, .9); charges_->SetLineColor(kCyan); chargesOnTrk_->SetLineColor(kGreen); - legend->AddEntry(charges_,"Charges"); - legend->AddEntry(chargesOnTrk_,"Charges On Track"); - legend->AddEntry(chargesOffTrk_,"Charges Off Track"); + legend->AddEntry(charges_, "Charges"); + legend->AddEntry(chargesOnTrk_, "Charges On Track"); + legend->AddEntry(chargesOffTrk_, "Charges Off Track"); charges_->Draw("e"); chargesOnTrk_->Draw("same e"); chargesOffTrk_->Draw("same e"); @@ -365,7 +363,7 @@ void SVTClusterAnaProcessor::PlotClusterLayersNTD(){ layersOffTrkNTD_->GetXaxis()->SetTitle("Width (strip)"); layersOffTrkNTD_->GetYaxis()->SetTitle("Hits"); - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle("NTD Layers for All Clusters"); layersNTD_->Draw("e"); c1->SaveAs("allClustersNTD.png"); @@ -382,12 +380,12 @@ void SVTClusterAnaProcessor::PlotClusterLayersNTD(){ c1->Clear(); layersNTD_->SetTitle("NTD Cluster Strip Width for all Cluster Cuts"); - auto legend = new TLegend(0.3,0.8,.68,.9); + auto legend = new TLegend(0.3, 0.8, .68, .9); layersNTD_->SetLineColor(kCyan); layersOnTrkNTD_->SetLineColor(kGreen); - legend->AddEntry(layersNTD_,"Layers"); - legend->AddEntry(layersOnTrkNTD_,"Layers On Track"); - legend->AddEntry(layersOffTrkNTD_,"Layers Off Track"); + legend->AddEntry(layersNTD_, "Layers"); + legend->AddEntry(layersOnTrkNTD_, "Layers On Track"); + legend->AddEntry(layersOffTrkNTD_, "Layers Off Track"); layersNTD_->Draw("e"); layersOnTrkNTD_->Draw("same e"); layersOffTrkNTD_->Draw("same e"); @@ -409,7 +407,7 @@ void SVTClusterAnaProcessor::PlotClusterChargesNTD(){ chargesOnTrkNTD_->GetXaxis()->SetTitle("Charge"); chargesOnTrkNTD_->GetYaxis()->SetTitle("Hits"); - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle("NTD Charges for All Clusters"); chargesNTD_->Draw("e"); c1->SaveAs("allClustersChargeNTD.png"); @@ -426,12 +424,12 @@ void SVTClusterAnaProcessor::PlotClusterChargesNTD(){ c1->Clear(); chargesNTD_->SetTitle("NTD Charge Distribution for all Charges"); - auto legend = new TLegend(0.3,0.8,.68,.9); + auto legend = new TLegend(0.3, 0.8, .68, .9); chargesNTD_->SetLineColor(kCyan); chargesOnTrkNTD_->SetLineColor(kGreen); - legend->AddEntry(chargesNTD_,"Charges"); - legend->AddEntry(chargesOnTrkNTD_,"Charges On Track"); - legend->AddEntry(chargesOffTrkNTD_,"Charges Off Track"); + legend->AddEntry(chargesNTD_, "Charges"); + legend->AddEntry(chargesOnTrkNTD_, "Charges On Track"); + legend->AddEntry(chargesOffTrkNTD_, "Charges Off Track"); chargesNTD_->Draw("e"); chargesOnTrkNTD_->Draw("same e"); chargesOffTrkNTD_->Draw("same e"); @@ -448,7 +446,7 @@ void SVTClusterAnaProcessor::PlotClusterPositions(){ positions_->GetXaxis()->SetTitle("Layer"); positions_->GetYaxis()->SetTitle("Hits"); - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle("Cluster Position for all Clusters"); positions_->Draw("e"); c1->SaveAs("positions.png"); @@ -490,7 +488,7 @@ void SVTClusterAnaProcessor::PlotClusterTimes(){ timesOffTrk_->GetXaxis()->SetTitle("Time (ns)"); timesOffTrk_->GetYaxis()->SetTitle("Hits"); - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle("Times for All Clusters"); times_->Draw(); c1->SaveAs("alltimes.png"); @@ -507,12 +505,12 @@ void SVTClusterAnaProcessor::PlotClusterTimes(){ c1->Clear(); times_->SetTitle("Cluster Times for all Cluster Cuts"); - auto legend = new TLegend(0.3,0.8,.68,.9); + auto legend = new TLegend(0.3, 0.8, .68, .9); times_->SetLineColor(kCyan); timesOnTrk_->SetLineColor(kGreen); - legend->AddEntry(times_,"Times"); - legend->AddEntry(timesOnTrk_,"Times On Track"); - legend->AddEntry(timesOffTrk_,"Times Off Track"); + legend->AddEntry(times_, "Times"); + legend->AddEntry(timesOnTrk_, "Times On Track"); + legend->AddEntry(timesOffTrk_, "Times Off Track"); times_->Draw("e"); timesOnTrk_->Draw("same e"); timesOffTrk_->Draw("same e"); @@ -533,7 +531,7 @@ void SVTClusterAnaProcessor::PlotClusterTimesNTD(){ timesOffTrkNTD_->GetXaxis()->SetTitle("Time (ns)"); timesOffTrkNTD_->GetYaxis()->SetTitle("Hits"); - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle("Times for All Clusters"); timesNTD_->Draw("e"); c1->SaveAs("alltimesNTD.png"); @@ -550,12 +548,12 @@ void SVTClusterAnaProcessor::PlotClusterTimesNTD(){ c1->Clear(); timesNTD_->SetTitle("Cluster Times for all Cluster Cuts"); - auto legend = new TLegend(0.3,0.8,.68,.9); + auto legend = new TLegend(0.3, 0.8, .68, .9); timesNTD_->SetLineColor(kCyan); timesOnTrkNTD_->SetLineColor(kGreen); - legend->AddEntry(timesNTD_,"Times"); - legend->AddEntry(timesOnTrkNTD_,"Times On Track"); - legend->AddEntry(timesOffTrkNTD_,"Times Off Track"); + legend->AddEntry(timesNTD_, "Times"); + legend->AddEntry(timesOnTrkNTD_, "Times On Track"); + legend->AddEntry(timesOffTrkNTD_, "Times Off Track"); timesNTD_->Draw("e"); timesOnTrkNTD_->Draw("same e"); timesOffTrkNTD_->Draw("same e"); @@ -568,29 +566,29 @@ void SVTClusterAnaProcessor::PlotClusterTimesNTD(){ void SVTClusterAnaProcessor::TrackPlot(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); - //FIRST I DO THE PROFILES OF THE NSHARED HITS PLOTS - + + // First, I do the profiles of the shared hits plots TProfile* p1 = Z0VNShare2Hist_->ProfileX("p1"); TProfile* p2 = Z0VNShare2HistCut_->ProfileX("p2"); - auto legend = new TLegend(0.3,0.8,.68,.9); + auto legend = new TLegend(0.3, 0.8, .68, .9); p2->SetLineColor(kRed); p2->SetLineWidth(2.0); p1->SetLineWidth(2.0); - legend->AddEntry(p1,"Shared Profile Not Cut"); - legend->AddEntry(p2,"Shared Profile Cut"); + legend->AddEntry(p1, "Shared Profile Not Cut"); + legend->AddEntry(p2, "Shared Profile Cut"); p1->Draw("e"); p2->Draw("same e"); legend->Draw("same e"); c1->SaveAs("Z0VSharedProfile.png"); c1->Clear(); - //Now I do the charge distribution for shared and unshared hits overlayed. - legend = new TLegend(0.3,0.8,.68,.9); + // Now I do the charge distribution for shared and unshared hits overlayed. + legend = new TLegend(0.3, 0.8, .68, .9); SharedAmplitudes_->SetLineColor(kRed); SharedAmplitudes_->SetLineWidth(2.0); UnSharedAmplitudes_->SetLineWidth(2.0); - legend->AddEntry(SharedAmplitudes_,"Charge Distribution for Shared Clusters"); - legend->AddEntry(UnSharedAmplitudes_,"Charge Distribution for UnShared Clusters"); + legend->AddEntry(SharedAmplitudes_, "Charge Distribution for Shared Clusters"); + legend->AddEntry(UnSharedAmplitudes_, "Charge Distribution for UnShared Clusters"); UnSharedAmplitudes_->Draw("e"); SharedAmplitudes_->Draw("same e"); legend->Draw("same e"); @@ -598,14 +596,14 @@ void SVTClusterAnaProcessor::TrackPlot(){ c1->SaveAs("SharedVUnSharedChargeDist.png"); c1->Clear(); - //Now I do the time distribution for shared and unshared hits overlayed. + // Now I do the time distribution for shared and unshared hits overlayed. SharedTimes_->SetTitle("The Time of Clusters Shared Between Tracks"); - legend = new TLegend(0.3,0.8,.68,.9); + legend = new TLegend(0.3, 0.8, .68, .9); SharedTimes_->SetLineColor(kRed); SharedTimes_->SetLineWidth(2.0); UnSharedTimes_->SetLineWidth(2.0); - legend->AddEntry(SharedTimes_,"Time Distribution for Shared Clusters"); - legend->AddEntry(UnSharedTimes_,"Time Distribution for UnShared Clusters"); + legend->AddEntry(SharedTimes_, "Time Distribution for Shared Clusters"); + legend->AddEntry(UnSharedTimes_, "Time Distribution for UnShared Clusters"); UnSharedTimes_->Draw("e"); SharedTimes_->Draw("same e"); legend->Draw("same e"); diff --git a/processors/src/SvtRawDataAnaProcessor.cxx b/processors/src/SvtRawDataAnaProcessor.cxx index 0ae64cef6..b42e400bf 100644 --- a/processors/src/SvtRawDataAnaProcessor.cxx +++ b/processors/src/SvtRawDataAnaProcessor.cxx @@ -17,9 +17,9 @@ void SvtRawDataAnaProcessor::configure(const ParameterSet& parameters) { std::cout << "Configuring SvtRawDataAnaProcessor" << std::endl; try { - debug_ = parameters.getInteger("debug"); - anaName_ = parameters.getString("anaName"); - svtHitColl_ = parameters.getString("trkrHitColl"); + debug_ = parameters.getInteger("debug"); + anaName_ = parameters.getString("anaName"); + svtHitColl_ = parameters.getString("trkrHitColl"); histCfgFilename_ = parameters.getString("histCfg"); regionSelections_ = parameters.getVString("regionDefinitions"); TimeRef_ = parameters.getDouble("timeref"); @@ -38,16 +38,16 @@ void SvtRawDataAnaProcessor::configure(const ParameterSet& parameters) { } float SvtRawDataAnaProcessor::str_to_float(std::string token){ - std::string top1=token.substr(0,token.find(".")); - const char *top=top1.c_str(); - std::string bot1=token.substr(token.find(".")+1); - const char *bottom=bot1.c_str(); + std::string top1 = token.substr(0, token.find(".")); + const char *top = top1.c_str(); + std::string bot1 = token.substr(token.find(".") + 1); + const char *bottom = bot1.c_str(); float base = 0.0; - for(int J=0;J baselines; for(int i=0; i<24576; i++){ - std::getline(myfile,s); - std::getline(myfile2,s2); - int feb=0; - int hyb=0; - int ch=0; - if(i>=4096){ - feb=((i-4096)/2560); - hyb=(i-4096-feb*2560)/640; - ch=i-4096-feb*2560-hyb*640; - }else{ - feb=i/2048; - hyb=(i-feb*2048)/512; - ch=i-feb*2048-hyb*512; + std::getline(myfile, s); + std::getline(myfile2, s2); + int feb = 0; + int hyb = 0; + int ch = 0; + if (i>=4096){ + feb = ((i-4096)/2560); + hyb = (i-4096-feb*2560)/640; + ch = i-4096-feb*2560-hyb*640; + } else { + feb = i/2048; + hyb = (i-feb*2048)/512; + ch = i-feb*2048-hyb*512; } - for(int I=0;I<5;I++){ - std::string token=s2.substr(0,s2.find(",")); - s2=s2.substr(s2.find(",")+1); - if(I>=2){ - if(i<=4096){ - times1_[feb][hyb][ch][I-2]=str_to_float(token); - }else{ - times2_[feb][hyb][ch][I-2]=str_to_float(token); + for (int j=0; j<5; j++){ + std::string token = s2.substr(0,s2.find(",")); + s2 = s2.substr(s2.find(",")+1); + if (j>=2){ + if (i<=4096){ + times1_[feb][hyb][ch][j-2] = str_to_float(token); + } else { + times2_[feb][hyb][ch][j-2] = str_to_float(token); } } } - for(int I=0;I<13;I++){ - if(I>0){ - if(i<=4096){ - std::string token=s.substr(0,s.find(" ")); - if(debug_){ + for(int j=0; j<13; j++){ + if (j>0){ + if (i<=4096){ + std::string token = s.substr(0, s.find(" ")); + if (debug_){ std::cout<SetBranchAddress(svtHitColl_.c_str() , &svtHits_ , &bsvtHits_ ); - tree_->SetBranchAddress("FinalStateParticles_KF",&Part_,&bPart_); - tree_->SetBranchAddress("SiClusters",&Clusters_,&bClusters_); - tree_->SetBranchAddress("EventHeader",&evH_,&bevH_); + tree_ = tree; + tree_->SetBranchAddress(svtHitColl_.c_str(), &svtHits_, &bsvtHits_); + tree_->SetBranchAddress("FinalStateParticles_KF", &Part_, &bPart_); + tree_->SetBranchAddress("SiClusters", &Clusters_, &bClusters_); + tree_->SetBranchAddress("EventHeader", &evH_, &bevH_); for (unsigned int i_reg = 0; i_reg < regionSelections_.size(); i_reg++) { @@ -177,11 +176,13 @@ void SvtRawDataAnaProcessor::initialize(TTree* tree) { } bool SvtRawDataAnaProcessor::process(IEvent* ievent) { - Float_t TimeRef=-0.0; - Float_t AmpRef=1000.0; - double weight = 1.;int count1=0;int count2=0; + Float_t TimeRef = -0.0; + Float_t AmpRef = 1000.0; + double weight = 1.; + int count1 = 0; + int count2 = 0; long eventTime = evH_->getEventTime(); - bool doClMatch = true; + bool doClMatch = true; int stripID = -10000; int hitc = 0; @@ -191,172 +192,170 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { //ONLY POSITRONS, MAY USE FEE's //ONCE I DETERMINE A CLUSTER WHICH IS IN LINE WITH TRIG, I CAN USE ANY CLUSTERS CLOSE IN TIME. - int trigPhase = (int)((eventTime%24)/4); - if((trigPhase!=tphase_)&&(tphase_!=6)){return true;} + int trigPhase = (int)((eventTime%24)/4); + if ((trigPhase!=tphase_)&&(tphase_!=6)) { return true; } - for(unsigned int i = 0; isize();i++){ + for (unsigned int i = 0; isize(); i++){ Clusters_->at(i)->getLayer(); } - for(unsigned int I = 0; I < svtHits_->size(); I++){ + for (unsigned int I = 0; I < svtHits_->size(); I++){ RawSvtHit * thisHit = svtHits_->at(I); int getNum = thisHit->getFitN(); - if(doClMatch){ - bool Continue = true; - for(int i = 0; isize();i++){ - if(Part_->at(i)->getPDG()==22){continue;} - if(Part_->at(i)->getCluster().getEnergy()<0){continue;} - if(not((Part_->at(i)->getCluster().getTime()<=40)and(Part_->at(i)->getCluster().getTime()>=36))){continue;} - for(int j = 0; jat(i)->getTrack().getSvtHits().GetEntries();j++){ - //std::cout<<"Do I break here 6"<size(); i++){ + if (Part_->at(i)->getPDG()==22) { continue; } + if (Part_->at(i)->getCluster().getEnergy() < 0) { continue; } + if (!((Part_->at(i)->getCluster().getTime()<=40)&&(Part_->at(i)->getCluster().getTime()>=36))) { continue; } + for (int j = 0; jat(i)->getTrack().getSvtHits().GetEntries(); j++){ TrackerHit * tHit = (TrackerHit*)(Part_->at(i)->getTrack().getSvtHits().At(j)); double TrackTime = Part_->at(i)->getTrack().getTrackTime(); - for(int k = 0;kgetRawHits().GetEntries();k++){ + for (int k = 0; kgetRawHits().GetEntries(); k++){ RawSvtHit * rHit = (RawSvtHit*)(tHit->getRawHits().At(k)); - int mode=0; - if((rHit->getT0(0)==thisHit->getT0(0))and(mode==0)){//or(mode==2))){ - //This is the HIT ON TRACK Modes - bool InCluster = false; - int layc = 0;//THE PURPOSE OF layc IS TO COUNT THE NUMBER OF HITS PER LAYER - for(int Cl = 0; Cl < Clusters_->size(); Cl++){ - for(int Clh = 0; Clh < Clusters_->at(Cl)->getRawHits().GetEntries(); Clh++){ - RawSvtHit * cluHit = (RawSvtHit*)(Clusters_->at(Cl)->getRawHits().At(Clh)); - if((cluHit->getLayer()==thisHit->getLayer())and(cluHit->getModule()==thisHit->getModule())){ + int mode = 0; + if ((rHit->getT0(0)==thisHit->getT0(0))&&(mode==0)){//or(mode==2))){ + // This is the HIT ON TRACK Modes + bool inCluster = false; + int layc = 0; // THE PURPOSE OF layc IS TO COUNT THE NUMBER OF HITS PER LAYER + for (int cl = 0; cl < Clusters_->size(); cl++){ + for (int clh = 0; clh < Clusters_->at(cl)->getRawHits().GetEntries(); clh++){ + RawSvtHit * cluHit = (RawSvtHit*)(Clusters_->at(cl)->getRawHits().At(clh)); + if ((cluHit->getLayer()==thisHit->getLayer())&&(cluHit->getModule()==thisHit->getModule())){ layc++; } - if((cluHit->getT0(0)==thisHit->getT0(0))){//and(not(Clusters_->at(Cl)->getID()==tHit->getID()))){ - InCluster = true; - hitc=Clusters_->at(Cl)->getRawHits().GetEntries(); - hitl=layc; - if(Clusters_->at(Cl)->getRawHits().GetEntries()==2){ - RawSvtHit * otherHit = (RawSvtHit*)(Clusters_->at(Cl)->getRawHits().At((Clh+1)%2)); + if ((cluHit->getT0(0)==thisHit->getT0(0))){ // and(not(Clusters_->at(cl)->getID()==tHit->getID()))){ + inCluster = true; + hitc = Clusters_->at(cl)->getRawHits().GetEntries(); + hitl = layc; + if (Clusters_->at(cl)->getRawHits().GetEntries()==2){ + RawSvtHit * otherHit = (RawSvtHit*)(Clusters_->at(cl)->getRawHits().At((clh+1)%2)); otherTime = otherHit->getT0(0); } } } } - if(InCluster){ - Continue = false; + if (inCluster){ + continue_flag = false; } } - if((rHit->getT0(0)<=-30)and(not(rHit->getT0(0)==thisHit->getT0(0)))and(mode==1)){ - //This is the HIT OFF TRACK Mode - //You are looking at the really early time on track hits, and specifically at other hits in the same layer and module - //to see if you have evidence of a misplaced hit. + if ((rHit->getT0(0)<=-30)&&(not(rHit->getT0(0)==thisHit->getT0(0)))&&(mode==1)){ + // This is the HIT OFF TRACK Mode + // You are looking at the really early time on track hits, and specifically at other hits in the same layer and module + // to see if you have evidence of a misplaced hit. - if((rHit->getLayer()==thisHit->getLayer())and(rHit->getModule()==thisHit->getModule())){ - stripID=rHit->getStrip(); - //This is conditioned on it being in clusters. - - bool InCluster = false; - int layc = 0;//THE PURPOSE OF layc IS TO COUNT THE NUMBER OF HITS PER LAYER - for(int Cl = 0; Cl < Clusters_->size(); Cl++){ - for(int Clh = 0; Clh < Clusters_->at(Cl)->getRawHits().GetEntries(); Clh++){ - RawSvtHit * cluHit = (RawSvtHit*)(Clusters_->at(Cl)->getRawHits().At(Clh)); - if((cluHit->getLayer()==thisHit->getLayer())and(cluHit->getModule()==thisHit->getModule())){ + if ((rHit->getLayer()==thisHit->getLayer())&&(rHit->getModule()==thisHit->getModule())){ + stripID = rHit->getStrip(); + // This is conditioned on it being in clusters. + bool inCluster = false; + int layc = 0; // THE PURPOSE OF layc IS TO COUNT THE NUMBER OF HITS PER LAYER + for( int cl = 0; cl < Clusters_->size(); cl++){ + for (int clh = 0; clh < Clusters_->at(cl)->getRawHits().GetEntries(); clh++){ + RawSvtHit * cluHit = (RawSvtHit*)(Clusters_->at(cl)->getRawHits().At(clh)); + if ((cluHit->getLayer()==thisHit->getLayer())&&(cluHit->getModule()==thisHit->getModule())){ layc++; } - if((cluHit->getT0(0)==thisHit->getT0(0))and(not(Clusters_->at(Cl)->getID()==tHit->getID()))){ - InCluster = true; - hitc=Clusters_->at(Cl)->getRawHits().GetEntries(); - hitl=layc; + if ((cluHit->getT0(0)==thisHit->getT0(0))&&(!(Clusters_->at(cl)->getID()==tHit->getID()))){ + inCluster = true; + hitc = Clusters_->at(cl)->getRawHits().GetEntries(); + hitl = layc; } } } - if(InCluster){ - Continue = false; + if(inCluster){ + continue_flag = false; } } } } } } - if(Continue){ + if(continue_flag){ return true; } - } - for(unsigned int i_reg = 0; i_reg < regionSelections_.size(); i_reg++){ - for(unsigned int J=0; JpassCutEq("getN_et",getNum,weight))){continue;} + if (!(reg_selectors_[regions_[i_reg]]->passCutEq("getN_et", getNum,weight))) { continue; } - if(getNum==2){ - TimeDiff=(thisHit->getT0(J))-(thisHit->getT0((J+1)%2)); - AmpDiff=(thisHit->getT0(J))-(thisHit->getT0((J+1)%2)); - if(!(reg_selectors_[regions_[i_reg]]->passCutLt("TimeDiff_lt",TimeDiff*TimeDiff,weight))){continue;} + if (getNum==2){ + TimeDiff = (thisHit->getT0(j))-(thisHit->getT0((j+1)%2)); + AmpDiff = (thisHit->getT0(j))-(thisHit->getT0((j+1)%2)); + if (!(reg_selectors_[regions_[i_reg]]->passCutLt("TimeDiff_lt", TimeDiff*TimeDiff, weight))) { continue; } } - if(!(reg_selectors_[regions_[i_reg]]->passCutEq("getId_lt",J,weight))){continue;} - if(!(reg_selectors_[regions_[i_reg]]->passCutEq("getId_gt",J,weight))){continue;} - if(!(reg_selectors_[regions_[i_reg]]->passCutLt("chi_lt",thisHit->getChiSq(J),weight))){continue;} - if(!(reg_selectors_[regions_[i_reg]]->passCutGt("chi_gt",thisHit->getChiSq(J),weight))){continue;} + if (!(reg_selectors_[regions_[i_reg]]->passCutEq("getId_lt", j, weight))) { continue; } + if (!(reg_selectors_[regions_[i_reg]]->passCutEq("getId_gt", j, weight))) { continue; } + if (!(reg_selectors_[regions_[i_reg]]->passCutLt("chi_lt", thisHit->getChiSq(j), weight))) { continue; } + if (!(reg_selectors_[regions_[i_reg]]->passCutGt("chi_gt", thisHit->getChiSq(j), weight))) { continue; } - if(!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_ft",(((thisHit->getT0(J))-TimeRef)*((thisHit->getT0(J))-TimeRef)<((thisHit->getT0((J+1)%getNum)-TimeRef)*(thisHit->getT0((J+1)%getNum)-TimeRef)+.00001)),weight))){continue;} - if(i_regpassCutLt("doing_ct",(((thisHit->getT0(J))-TimeRef)*((thisHit->getT0(J))-TimeRef)>((thisHit->getT0((J+1)%getNum)-TimeRef)*(thisHit->getT0((J+1)%getNum)-TimeRef)+.00001)),weight))){continue;} - }else{ - if(getNum==2){ - if(!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_ct",(((thisHit->getT0(J))-TimeRef)*((thisHit->getT0(J))-TimeRef)>((thisHit->getT0((J+1)%getNum)-TimeRef)*(thisHit->getT0((J+1)%getNum)-TimeRef)+.00001)),weight))){continue;} + if (!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_ft", (((thisHit->getT0(j))-TimeRef)*((thisHit->getT0(j))-TimeRef) < ((thisHit->getT0((j+1)%getNum)-TimeRef)*(thisHit->getT0((j+1)%getNum)-TimeRef)+.00001)), weight))) { continue; } + if (i_reg < regionSelections_.size()-1){ + if (!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_ct", (((thisHit->getT0(j))-TimeRef)*((thisHit->getT0(j))-TimeRef) > ((thisHit->getT0((j+1)%getNum)-TimeRef)*(thisHit->getT0((j+1)%getNum)-TimeRef)+.00001)), weight))) { continue; } + } else { + if (getNum==2){ + if (!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_ct", (((thisHit->getT0(j))-TimeRef)*((thisHit->getT0(j))-TimeRef) > ((thisHit->getT0((j+1)%getNum)-TimeRef)*(thisHit->getT0((j+1)%getNum)-TimeRef)+.00001)), weight))) { continue; } } } - if(!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_ca",(((thisHit->getAmp(J))-AmpRef)*((thisHit->getAmp(J))-AmpRef)<((thisHit->getAmp((J+1)%getNum)-AmpRef)*(thisHit->getAmp((J+1)%getNum)-AmpRef)+.00001)),weight))){continue;} + if (!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_ca", (((thisHit->getAmp(j))-AmpRef)*((thisHit->getAmp(j))-AmpRef) < ((thisHit->getAmp((j+1)%getNum)-AmpRef)*(thisHit->getAmp((j+1)%getNum)-AmpRef)+.00001)), weight))) { continue; } - if(!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_fterr",(((thisHit->getT0err(J))-TimeRef)*((thisHit->getT0err(J))-TimeRef)<((thisHit->getT0err((J+1)%getNum)-TimeRef)*(thisHit->getT0err((J+1)%getNum)-TimeRef)+.00001)),weight))){continue;} - if(!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_cterr",(((thisHit->getT0err(J))-0.0)*((thisHit->getT0err(J))-0.0)>((thisHit->getT0err((J+1)%getNum)-0.0)*(thisHit->getT0err((J+1)%getNum)-0.0)+.00001)),weight))){continue;} + if (!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_fterr", (((thisHit->getT0err(j))-TimeRef)*((thisHit->getT0err(j))-TimeRef) < ((thisHit->getT0err((j+1)%getNum)-TimeRef)*(thisHit->getT0err((j+1)%getNum)-TimeRef)+.00001)), weight))) { continue; } + if (!(reg_selectors_[regions_[i_reg]]->passCutLt("doing_cterr", (((thisHit->getT0err(j))-0.0)*((thisHit->getT0err(j))-0.0) > ((thisHit->getT0err((j+1)%getNum)-0.0)*(thisHit->getT0err((j+1)%getNum)-0.0)+.00001)),weight))) { continue; } - if(!(reg_selectors_[regions_[i_reg]]->passCutLt("amp_lt",thisHit->getAmp(0),weight))){continue;} - if(!(reg_selectors_[regions_[i_reg]]->passCutGt("amp_gt",thisHit->getAmp(0),weight))){continue;} - - if(!(reg_selectors_[regions_[i_reg]]->passCutLt("time_lt",thisHit->getT0(0),weight))){continue;} - if(!(reg_selectors_[regions_[i_reg]]->passCutGt("time_gt",thisHit->getT0(0),weight))){continue;} + if (!(reg_selectors_[regions_[i_reg]]->passCutLt("amp_lt", thisHit->getAmp(0), weight))) { continue; } + if (!(reg_selectors_[regions_[i_reg]]->passCutGt("amp_gt", thisHit->getAmp(0), weight))) { continue; } - if(!(reg_selectors_[regions_[i_reg]]->passCutLt("Otime_lt",(float)(thisHit->getT0((J+1)%getNum)),weight))){continue;} - if(!(reg_selectors_[regions_[i_reg]]->passCutGt("Otime_gt",(float)(thisHit->getT0((J+1)%getNum)),weight))){continue;} + if (!(reg_selectors_[regions_[i_reg]]->passCutLt("time_lt", thisHit->getT0(0), weight))) { continue; } + if (!(reg_selectors_[regions_[i_reg]]->passCutGt("time_gt", thisHit->getT0(0), weight))) { continue; } - if(!(reg_selectors_[regions_[i_reg]]->passCutLt("Stime_lt",(float)(thisHit->getT0((J)%getNum)),weight))){continue;} - if(!(reg_selectors_[regions_[i_reg]]->passCutGt("Stime_gt",(float)(thisHit->getT0((J)%getNum)),weight))){continue;} + if (!(reg_selectors_[regions_[i_reg]]->passCutLt("Otime_lt", (float)(thisHit->getT0((j+1)%getNum)), weight))) { continue; } + if (!(reg_selectors_[regions_[i_reg]]->passCutGt("Otime_gt", (float)(thisHit->getT0((j+1)%getNum)), weight))) { continue; } + if (!(reg_selectors_[regions_[i_reg]]->passCutLt("Stime_lt", (float)(thisHit->getT0((j)%getNum)), weight))) { continue; } + if (!(reg_selectors_[regions_[i_reg]]->passCutGt("Stime_gt", (float)(thisHit->getT0((j)%getNum)), weight))) { continue; } - if(!(reg_selectors_[regions_[i_reg]]->passCutLt("amp2_lt",thisHit->getAmp(0),weight))){continue;} - if(!(reg_selectors_[regions_[i_reg]]->passCutEq("channel", (thisHit->getStrip()),weight))){continue;} - int * adcs=thisHit->getADCs(); + if (!(reg_selectors_[regions_[i_reg]]->passCutLt("amp2_lt", thisHit->getAmp(0), weight))) { continue; } + if (!(reg_selectors_[regions_[i_reg]]->passCutEq("channel", (thisHit->getStrip()), weight))) { continue; } + int * adcs = thisHit->getADCs(); int maxx = 0; - for(unsigned int K=0; K<6; K++){ - if(maxxpassCutEq("first_max",adcs[0]-maxx,weight))){continue;} + if (!(reg_selectors_[regions_[i_reg]]->passCutEq("first_max", adcs[0]-maxx, weight))) { continue; } bool helper = false; - if(doSample_==1){ + if (doSample_==1){ int len=*(&readout+1)-readout; - for(int KK=0;KKgetEventNumber(); - if((regions_[i_reg]=="CTFit")and((thisHit->getT0(J)<26.0)or(thisHit->getT0(J)>30.0))){continue;} - sample(thisHit,regions_[i_reg],ievent,eventTime,N); + if ((regions_[i_reg]=="CTFit")&&((thisHit->getT0(j)<26.0)||(thisHit->getT0(j)>30.0))) { continue; } + sample(thisHit,regions_[i_reg], ievent, eventTime, N); } - reg_histos_[regions_[i_reg]]->FillHistograms(thisHit,weight,J,I,TimeDiff,AmpDiff,stripID,hitc,hitl,otherTime); + reg_histos_[regions_[i_reg]]->FillHistograms(thisHit, weight, j, I, TimeDiff, AmpDiff, stripID, hitc, hitl, otherTime); } } } return true; } - void SvtRawDataAnaProcessor::sample(RawSvtHit* thisHit,std::string word, IEvent* ievent,long T,int N){ + void SvtRawDataAnaProcessor::sample(RawSvtHit* thisHit, std::string word, IEvent* ievent, long T, int N){ auto mod = std::to_string(thisHit->getModule()); auto lay = std::to_string(thisHit->getLayer()); //swTag= mmapper_->getStringFromSw("ly"+lay+"_m"+mod); - std::string helper = mmapper_->getHwFromSw("ly"+lay+"_m"+mod); + std::string helper = mmapper_->getHwFromSw("ly" + lay + "_m" + mod); //std::cout<=2)and(word=="OneFit")){return;} - if((feb<2)and(word=="CTFit")){return;} - if(thisHit->getChiSq(0)<.85){return;} + if ((feb>=2) && (word=="OneFit")) { return; } + if ((feb<2) && (word=="CTFit")) { return; } + if (thisHit->getChiSq(0) < .85) { return; } - int BigCount = 0; - if(feb<=1){ - BigCount+=feb*2048+hyb*512+(int)(thisHit->getStrip()); - }else{ - BigCount+=4096; - BigCount+=(feb-2)*2560+hyb*640+(int)(thisHit->getStrip()); + int count = 0; + if (feb <=1 ){ + count += feb*2048 + hyb*512 + (int)(thisHit->getStrip()); + } else { + count += 4096; + count += (feb-2)*2560 + hyb*640 + (int)(thisHit->getStrip()); } - int * adcs2=thisHit->getADCs(); + int * adcs2 = thisHit->getADCs(); TF1* fitfunc = fourPoleFitFunction("Pulse 0",0); TF1* fitfunc2 = fourPoleFitFunction("Pulse 1",0); TF1* fitfunc3 = fourPoleFitFunction("Addition",1); - float TimeShift[2] = {-1*rETime(-(thisHit->getT0(0)),T),-1*rETime(-(thisHit->getT0(1)),T)}; - - fitfunc->FixParameter(0,TimeShift[0]); - fitfunc->FixParameter(3,thisHit->getAmp(0)); - if(feb<=1){ - fitfunc->FixParameter(1,times1_[feb][hyb][(int)thisHit->getStrip()][1]); - fitfunc->FixParameter(2,times1_[feb][hyb][(int)thisHit->getStrip()][2]); - fitfunc->FixParameter(4,baseErr1_[feb][hyb][(int)thisHit->getStrip()][1]); + float TimeShift[2] = {-1*rETime(-(thisHit->getT0(0)), T), -1*rETime(-(thisHit->getT0(1)), T)}; + + fitfunc->FixParameter(0, TimeShift[0]); + fitfunc->FixParameter(3, thisHit->getAmp(0)); + if (feb <=1 ){ + fitfunc->FixParameter(1, times1_[feb][hyb][(int)thisHit->getStrip()][1]); + fitfunc->FixParameter(2, times1_[feb][hyb][(int)thisHit->getStrip()][2]); + fitfunc->FixParameter(4, baseErr1_[feb][hyb][(int)thisHit->getStrip()][1]); //baseline->FixParameter(0,baseErr1_[feb][hyb][(int)thisHit->getStrip()][1]); - }else{ - fitfunc->FixParameter(1,times2_[feb-2][hyb][(int)thisHit->getStrip()][1]); - fitfunc->FixParameter(2,times2_[feb-2][hyb][(int)thisHit->getStrip()][2]); - fitfunc->FixParameter(4,baseErr2_[feb-2][hyb][(int)thisHit->getStrip()][1]); + } else { + fitfunc->FixParameter(1, times2_[feb-2][hyb][(int)thisHit->getStrip()][1]); + fitfunc->FixParameter(2, times2_[feb-2][hyb][(int)thisHit->getStrip()][2]); + fitfunc->FixParameter(4, baseErr2_[feb-2][hyb][(int)thisHit->getStrip()][1]); } - if(thisHit->getFitN()==2){ - fitfunc2->FixParameter(0,TimeShift[1]); - fitfunc2->FixParameter(3,thisHit->getAmp(1)); - - fitfunc3->FixParameter(0,TimeShift[0]); - fitfunc3->FixParameter(3,thisHit->getAmp(0)); - fitfunc3->FixParameter(5,TimeShift[1]); - fitfunc3->FixParameter(8,thisHit->getAmp(1)); - - if(feb<=1){ - fitfunc2->FixParameter(1,times1_[feb][hyb][(int)thisHit->getStrip()][1]); - fitfunc2->FixParameter(2,times1_[feb][hyb][(int)thisHit->getStrip()][2]); - fitfunc2->FixParameter(4,baseErr1_[feb][hyb][(int)thisHit->getStrip()][1]); - - fitfunc3->FixParameter(1,times1_[feb][hyb][(int)thisHit->getStrip()][1]); - fitfunc3->FixParameter(2,times1_[feb][hyb][(int)thisHit->getStrip()][2]); - fitfunc3->FixParameter(4,baseErr1_[feb][hyb][(int)thisHit->getStrip()][1]); - - fitfunc3->FixParameter(6,times1_[feb][hyb][(int)thisHit->getStrip()][1]); - fitfunc3->FixParameter(7,times1_[feb][hyb][(int)thisHit->getStrip()][2]); - - }else{ - fitfunc2->FixParameter(1,times2_[feb-2][hyb][(int)thisHit->getStrip()][1]); - fitfunc2->FixParameter(2,times2_[feb-2][hyb][(int)thisHit->getStrip()][2]); - fitfunc2->FixParameter(4,baseErr2_[feb-2][hyb][(int)thisHit->getStrip()][1]); - - fitfunc3->FixParameter(1,times2_[feb-2][hyb][(int)thisHit->getStrip()][1]); - fitfunc3->FixParameter(2,times2_[feb-2][hyb][(int)thisHit->getStrip()][2]); - fitfunc3->FixParameter(4,baseErr2_[feb-2][hyb][(int)thisHit->getStrip()][1]); - - fitfunc3->FixParameter(6,times2_[feb-2][hyb][(int)thisHit->getStrip()][1]); - fitfunc3->FixParameter(7,times2_[feb-2][hyb][(int)thisHit->getStrip()][2]); + if (thisHit->getFitN()==2){ + fitfunc2->FixParameter(0, TimeShift[1]); + fitfunc2->FixParameter(3, thisHit->getAmp(1)); + + fitfunc3->FixParameter(0, TimeShift[0]); + fitfunc3->FixParameter(3, thisHit->getAmp(0)); + fitfunc3->FixParameter(5, TimeShift[1]); + fitfunc3->FixParameter(8, thisHit->getAmp(1)); + + if (feb <=1 ){ + fitfunc2->FixParameter(1, times1_[feb][hyb][(int)thisHit->getStrip()][1]); + fitfunc2->FixParameter(2, times1_[feb][hyb][(int)thisHit->getStrip()][2]); + fitfunc2->FixParameter(4, baseErr1_[feb][hyb][(int)thisHit->getStrip()][1]); + + fitfunc3->FixParameter(1, times1_[feb][hyb][(int)thisHit->getStrip()][1]); + fitfunc3->FixParameter(2, times1_[feb][hyb][(int)thisHit->getStrip()][2]); + fitfunc3->FixParameter(4, baseErr1_[feb][hyb][(int)thisHit->getStrip()][1]); + + fitfunc3->FixParameter(6, times1_[feb][hyb][(int)thisHit->getStrip()][1]); + fitfunc3->FixParameter(7, times1_[feb][hyb][(int)thisHit->getStrip()][2]); + + } else { + fitfunc2->FixParameter(1, times2_[feb-2][hyb][(int)thisHit->getStrip()][1]); + fitfunc2->FixParameter(2, times2_[feb-2][hyb][(int)thisHit->getStrip()][2]); + fitfunc2->FixParameter(4, baseErr2_[feb-2][hyb][(int)thisHit->getStrip()][1]); + + fitfunc3->FixParameter(1, times2_[feb-2][hyb][(int)thisHit->getStrip()][1]); + fitfunc3->FixParameter(2, times2_[feb-2][hyb][(int)thisHit->getStrip()][2]); + fitfunc3->FixParameter(4, baseErr2_[feb-2][hyb][(int)thisHit->getStrip()][1]); + + fitfunc3->FixParameter(6, times2_[feb-2][hyb][(int)thisHit->getStrip()][1]); + fitfunc3->FixParameter(7, times2_[feb-2][hyb][(int)thisHit->getStrip()][2]); } } - int Length=MatchList_.size(); - for(int K=0; KgetStrip())+", chi_sqr value: "+std::to_string((float)thisHit->getChiSq(0)); + int Length = MatchList_.size(); + for (int k=0; kgetStrip()) + ", chi_sqr value: " + std::to_string((float)thisHit->getChiSq(0)); const char *thing1 = helper1.data(); TCanvas *c1 = new TCanvas("c"); - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle(thing1); float times[12]; float points[12]; float errors[12]; float zeroes[12]; - for(int i=0;i<6;i++){ - zeroes[i]=0.0; - if(feb<=1){ - times[i]=float(i)*24.0;//-27.0; - points[i]=adcs2[i]-baseErr1_[feb][hyb][(int)thisHit->getStrip()][i]; - errors[i]=baseErr1_[feb][hyb][(int)thisHit->getStrip()][i+6]; - }else{ - times[i]=float(i)*24.0;//rETime((float(i))*24.0,T);//(float(i))*24.0-27.0; - points[i]=adcs2[i]-baseErr2_[feb-2][hyb][(int)thisHit->getStrip()][i]; - errors[i]=baseErr2_[feb-2][hyb][(int)thisHit->getStrip()][i+6]; + for(int i=0; i<6; i++){ + zeroes[i] = 0.0; + if (feb <=1 ){ + times[i] = float(i)*24.0;//-27.0; + points[i] = adcs2[i]-baseErr1_[feb][hyb][(int)thisHit->getStrip()][i]; + errors[i] = baseErr1_[feb][hyb][(int)thisHit->getStrip()][i+6]; + } else { + times[i] = float(i)*24.0;//rETime((float(i))*24.0,T);//(float(i))*24.0-27.0; + points[i] = adcs2[i]-baseErr2_[feb-2][hyb][(int)thisHit->getStrip()][i]; + errors[i] = baseErr2_[feb-2][hyb][(int)thisHit->getStrip()][i+6]; } } - auto gr = new TGraphErrors(6,times,points,zeroes,errors); + auto gr = new TGraphErrors(6, times, points, zeroes, errors); gr->SetName("ADCs"); gr->SetTitle(thing1); gr->GetYaxis()->SetTitle("ADC Counts"); gr->GetXaxis()->SetTitle("ns"); - gr->GetXaxis()->SetLimits(-10.0,130.); + gr->GetXaxis()->SetLimits(-10.0, 130.); gr->GetHistogram()->SetMaximum(2000.); gr->GetHistogram()->SetMinimum(-500.); gr->Draw("AL*"); fitfunc->Draw("same"); - if(thisHit->getFitN()==2){ + if (thisHit->getFitN()==2){ fitfunc2->SetLineColor(kGreen); fitfunc2->Draw("same"); fitfunc3->SetLineColor(kOrange); @@ -471,15 +470,15 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { } auto legend = new TLegend(0.1,0.7,.48,.9); - legend->AddEntry("gr","ADC counts"); - legend->AddEntry("base","Offline Baselines"); - legend->AddEntry("Pulse 0","First Pulse"); - if(thisHit->getFitN()==2){ - legend->AddEntry("Pulse 1","Second Pulse"); - legend->AddEntry("Addition","Summed Fit"); + legend->AddEntry("gr", "ADC counts"); + legend->AddEntry("base", "Offline Baselines"); + legend->AddEntry("Pulse 0", "First Pulse"); + if (thisHit->getFitN()==2){ + legend->AddEntry("Pulse 1", "Second Pulse"); + legend->AddEntry("Addition", "Summed Fit"); } legend->Draw("same"); - std::string helper2=word+std::to_string(readout[K]-1)+".png"; + std::string helper2 = word + std::to_string(readout[k]-1) + ".png"; const char *thing2 = helper2.data(); c1->SaveAs(thing2); } diff --git a/processors/src/TrackHitCompareAnaProcessor.cxx b/processors/src/TrackHitCompareAnaProcessor.cxx index d68df7e0f..611bfa151 100644 --- a/processors/src/TrackHitCompareAnaProcessor.cxx +++ b/processors/src/TrackHitCompareAnaProcessor.cxx @@ -8,7 +8,7 @@ #include "TrackHitCompareAnaProcessor.h" #include -TrackHitAnaProcessor::TrackHitAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ +TrackHitAnaProcessor::TrackHitAnaProcessor(const std::string& name, Process& process) : Processor(name, process){ mmapper_ = new ModuleMapper(2021); } TrackHitAnaProcessor::~TrackHitAnaProcessor(){} @@ -36,163 +36,194 @@ void TrackHitAnaProcessor::configure(const ParameterSet& parameters) { void TrackHitAnaProcessor::initialize(TTree* tree) { fillDeads(); tree_= tree; - if(isMC_==1){ - layers1_=new TH1F("layers","MC Strip Width for All Clusters",12,0.0,12.0); - layersOnTrk1_=new TH1F("layersOnTrk","MC Strip Width for Clusters on Track",12,0.0,12.0); - layersOffTrk1_=new TH1F("layersOffTrk","MC Strip Width for Clusters off Track",12,0.0,12.0); - charges1_=new TH1F("charges","MC Charge Distribution for All Clusters",1000,0.0,0.000016); - chargesOnTrk1_=new TH1F("chargesOnTrk","MC Charge Distribution for On Track",1000,0.0,.000016); - chargesOffTrk1_=new TH1F("chargesOffTrk","MC Charge Distribution for Off Track",1000,0.0,0.000016); - - layersNTD1_=new TH1F("layersNTD","MC Strip Width for All Clusters",12,0.0,12.0); - layersOnTrkNTD1_=new TH1F("layersOnTrkNTD","MC Strip Width for Clusters on Track",12,0.0,12.0); - layersOffTrkNTD1_=new TH1F("layersOffTrkNTD","MC Strip Width for Clusters off Track",12,0.0,12.0); - chargesNTD1_=new TH1F("chargesNTD","MC Charge Distribution for All Clusters",1000,0.0,0.000016); - chargesOnTrkNTD1_=new TH1F("chargesOnTrkNTD","MC Charge Distribution for On Track",1000,0.0,.000016); - chargesOffTrkNTD1_=new TH1F("chargesOffTrkNTD","MC Charge Distribution for Off Track",1000,0.0,0.000016); - - positions1_=new TH1F("Positions","MC Location of Cluster Hit;Layer;Hits",14,0.0,14.0); - positionsOnTrk1_=new TH1F("PositionsOnTrk","MC Location of Cluster Hit for On Track",14,0.0,14.0); - ClusDistances1_=new TH1F("Minimum Cluster Difference","MC Minimum Distance Between Clusters",14,0.0,14.0); - ClusDistancesNTD1_=new TH1F("Minimum Cluster Difference","MC Minimum Distance Between Clusters",14,0.0,14.0); - - times1_=new TH1F("Times","MC Time of Cluster Hit",1000,-60.0,60.0); - timesOnTrk1_=new TH1F("TimesOnTrk","MC Time of On Track Cluster Hit",1000,-60.0,60.0); - timesOffTrk1_=new TH1F("TimesOffTrk","MC Time of Off Cluster Hit",1000,-60.0,60.0); - timesNTD1_=new TH1F("TimesNTD","MC Time of Cluster Hit NTD",1000,-60.0,60.0); - timesOnTrkNTD1_=new TH1F("TimesOnTrkNTD","MC Time of On Track Cluster Hit NTD",1000,-60.0,60.0); - timesOffTrkNTD1_=new TH1F("TimesOffTrkNTD","MC Time of Off Cluster Hit NTD",1000,-60.0,60.0); - - tree_->SetBranchAddress("SiClusters",&Clusters_,&bClusters_); - tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); - tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); + if (isMC_ == 1){ + layers1_ = new TH1F("layers", "MC Strip Width for All Clusters", 12, 0.0, 12.0); + layersOnTrk1_ = new TH1F("layersOnTrk", "MC Strip Width for Clusters on Track", 12, 0.0, 12.0); + layersOffTrk1_ = new TH1F("layersOffTrk", "MC Strip Width for Clusters off Track", 12, 0.0, 12.0); + charges1_ = new TH1F("charges", "MC Charge Distribution for All Clusters", 1000, 0.0, 0.000016); + chargesOnTrk1_ = new TH1F("chargesOnTrk", "MC Charge Distribution for On Track", 1000, 0.0, 0.000016); + chargesOffTrk1_ = new TH1F("chargesOffTrk", "MC Charge Distribution for Off Track", 1000, 0.0, 0.000016); + + layersNTD1_ = new TH1F("layersNTD", "MC Strip Width for All Clusters", 12, 0.0, 12.0); + layersOnTrkNTD1_ = new TH1F("layersOnTrkNTD", "MC Strip Width for Clusters on Track", 12, 0.0, 12.0); + layersOffTrkNTD1_ = new TH1F("layersOffTrkNTD", "MC Strip Width for Clusters off Track", 12, 0.0, 12.0); + chargesNTD1_ = new TH1F("chargesNTD", "MC Charge Distribution for All Clusters", 1000, 0.0, 0.000016); + chargesOnTrkNTD1_ = new TH1F("chargesOnTrkNTD", "MC Charge Distribution for On Track", 1000, 0.0, .000016); + chargesOffTrkNTD1_ = new TH1F("chargesOffTrkNTD", "MC Charge Distribution for Off Track", 1000, 0.0, 0.000016); + + positions1_ = new TH1F("Positions", "MC Location of Cluster Hit;Layer;Hits", 14, 0.0, 14.0); + positionsOnTrk1_ = new TH1F("PositionsOnTrk", "MC Location of Cluster Hit for On Track", 14, 0.0, 14.0); + ClusDistances1_ = new TH1F("Minimum Cluster Difference", "MC Minimum Distance Between Clusters", 14, 0.0, 14.0); + ClusDistancesNTD1_ = new TH1F("Minimum Cluster Difference", "MC Minimum Distance Between Clusters", 14, 0.0, 14.0); + + times1_ = new TH1F("Times", "MC Time of Cluster Hit", 1000, -60.0, 60.0); + timesOnTrk1_ = new TH1F("TimesOnTrk", "MC Time of On Track Cluster Hit", 1000, -60.0, 60.0); + timesOffTrk1_ = new TH1F("TimesOffTrk", "MC Time of Off Cluster Hit", 1000, -60.0, 60.0); + timesNTD1_ = new TH1F("TimesNTD", "MC Time of Cluster Hit NTD", 1000, -60.0, 60.0); + timesOnTrkNTD1_ = new TH1F("TimesOnTrkNTD", "MC Time of On Track Cluster Hit NTD", 1000, -60.0, 60.0); + timesOffTrkNTD1_ = new TH1F("TimesOffTrkNTD", "MC Time of Off Cluster Hit NTD", 1000, -60.0, 60.0); + + tree_->SetBranchAddress("SiClusters", &Clusters_, &bClusters_); + tree_->SetBranchAddress("SiClustersOnTrack_KF", &ClustersKF_, &bClustersKF_); + tree_->SetBranchAddress("SVTRawTrackerHits", &svtraw_, &bsvtraw_); return; } - //Instantiating the first layer - - layers1_=new TH1F("layers","Strip Width for All Clusters",12,0.0,12.0); - layersOnTrk1_=new TH1F("layersOnTrk","Strip Width for Clusters on Track",12,0.0,12.0); - layersOffTrk1_=new TH1F("layersOffTrk","Strip Width for Clusters off Track",12,0.0,12.0); - charges1_=new TH1F("charges","Charge Distribution for All Clusters",1000,0.0,0.000016); - chargesOnTrk1_=new TH1F("chargesOnTrk","Charge Distribution for On Track",1000,0.0,.000016); - chargesOffTrk1_=new TH1F("chargesOffTrk","Charge Distribution for Off Track",1000,0.0,0.000016); - - layersNTD1_=new TH1F("layersNTD","Strip Width for All Clusters",12,0.0,12.0); - layersOnTrkNTD1_=new TH1F("layersOnTrkNTD","Strip Width for Clusters on Track",12,0.0,12.0); - layersOffTrkNTD1_=new TH1F("layersOffTrkNTD","Strip Width for Clusters off Track",12,0.0,12.0); - chargesNTD1_=new TH1F("chargesNTD","Charge Distribution for All Clusters",1000,0.0,0.000016); - chargesOnTrkNTD1_=new TH1F("chargesOnTrkNTD","Charge Distribution for On Track",1000,0.0,.000016); - chargesOffTrkNTD1_=new TH1F("chargesOffTrkNTD","Charge Distribution for Off Track",1000,0.0,0.000016); - - positions1_=new TH1F("Positions","Location of Cluster Hit;Layer;Hits",14,0.0,14.0); - positionsOnTrk1_=new TH1F("PositionsOnTrk","Location of Cluster Hit for On Track",14,0.0,14.0); - ClusDistances1_=new TH1F("Minimum Cluster Difference","Minimum Distance Between Clusters",14,0.0,14.0); - ClusDistancesNTD1_=new TH1F("Minimum Cluster Difference","Minimum Distance Between Clusters",14,0.0,14.0); - - times1_=new TH1F("Times","Time of Cluster Hit",1000,-60.0,60.0); - timesOnTrk1_=new TH1F("TimesOnTrk","Time of On Track Cluster Hit",1000,-60.0,60.0); - timesOffTrk1_=new TH1F("TimesOffTrk","Time of Off Cluster Hit",1000,-60.0,60.0); - timesNTD1_=new TH1F("TimesNTD","Time of Cluster Hit NTD",1000,-60.0,60.0); - timesOnTrkNTD1_=new TH1F("TimesOnTrkNTD","Time of On Track Cluster Hit NTD",1000,-60.0,60.0); - timesOffTrkNTD1_=new TH1F("TimesOffTrkNTD","Time of Off Cluster Hit NTD",1000,-60.0,60.0); + + // Instantiating the first layer + layers1_ = new TH1F("layers", "Strip Width for All Clusters", 12, 0.0, 12.0); + layersOnTrk1_ = new TH1F("layersOnTrk", "Strip Width for Clusters on Track", 12, 0.0, 12.0); + layersOffTrk1_ = new TH1F("layersOffTrk", "Strip Width for Clusters off Track", 12, 0.0, 12.0); + charges1_ = new TH1F("charges", "Charge Distribution for All Clusters", 1000, 0.0, 0.000016); + chargesOnTrk1_ = new TH1F("chargesOnTrk", "Charge Distribution for On Track", 1000, 0.0, 0.000016); + chargesOffTrk1_ = new TH1F("chargesOffTrk", "Charge Distribution for Off Track", 1000, 0.0, 0.000016); + + layersNTD1_ = new TH1F("layersNTD", "Strip Width for All Clusters", 12, 0.0, 12.0); + layersOnTrkNTD1_ = new TH1F("layersOnTrkNTD", "Strip Width for Clusters on Track", 12, 0.0, 12.0); + layersOffTrkNTD1_ = new TH1F("layersOffTrkNTD", "Strip Width for Clusters off Track", 12, 0.0, 12.0); + chargesNTD1_ = new TH1F("chargesNTD", "Charge Distribution for All Clusters", 1000, 0.0, 0.000016); + chargesOnTrkNTD1_ = new TH1F("chargesOnTrkNTD", "Charge Distribution for On Track", 1000, 0.0, 0.000016); + chargesOffTrkNTD1_ = new TH1F("chargesOffTrkNTD", "Charge Distribution for Off Track", 1000, 0.0, 0.000016); + + positions1_ = new TH1F("Positions", "Location of Cluster Hit;Layer;Hits", 14, 0.0, 14.0); + positionsOnTrk1_ = new TH1F("PositionsOnTrk", "Location of Cluster Hit for On Track", 14, 0.0, 14.0); + ClusDistances1_ = new TH1F("Minimum Cluster Difference", "Minimum Distance Between Clusters", 14, 0.0, 14.0); + ClusDistancesNTD1_ = new TH1F("Minimum Cluster Difference", "Minimum Distance Between Clusters", 14, 0.0, 14.0); + + times1_ = new TH1F("Times", "Time of Cluster Hit", 1000, -60.0, 60.0); + timesOnTrk1_ = new TH1F("TimesOnTrk", "Time of On Track Cluster Hit", 1000, -60.0, 60.0); + timesOffTrk1_ = new TH1F("TimesOffTrk", "Time of Off Cluster Hit", 1000, -60.0, 60.0); + timesNTD1_ = new TH1F("TimesNTD", "Time of Cluster Hit NTD", 1000, -60.0, 60.0); + timesOnTrkNTD1_ = new TH1F("TimesOnTrkNTD", "Time of On Track Cluster Hit NTD", 1000, -60.0, 60.0); + timesOffTrkNTD1_ = new TH1F("TimesOffTrkNTD", "Time of Off Cluster Hit NTD", 1000, -60.0, 60.0); - if(doingTracks_){ - Z0VNShare2Hist1_= new TH2F("Z0VNShare2Hist","Z0 versus Number of Shared Hits No Cut",100,0,3,8,0,8); - Z0VNShare2HistCut1_= new TH2F("Z0VNShare2HistCut","Z0 versus Number of Shared Hits Momentum Cut",100,0,3,8,0,8); - SharedAmplitudes1_= new TH1F("SharedAmplitudes","The Amplitudes of Clusters Shared Between Tracks",1000,0.0,0.000016); - UnSharedAmplitudes1_= new TH1F("UnSharedAmplitudes","The Amplitudes of Clusters Not Shared Between Tracks",1000,0.0,0.000016); - SharedTimes1_= new TH1F("SharedTimes","The Times of Clusters Shared Between Tracks",1000,-60.0,60.0); - UnSharedTimes1_= new TH1F("UnSharedTimes","The Times of Clusters Not Shared Between Tracks",1000,-60.0,60.0); - TrackMomentumInTime1_ = new TH1F("TrackMomentumInTime","The Momentum of In Time Tracks",1000,0.0,7.0); - TrackMomentumOutTime1_ = new TH1F("TrackMomentumOutTime","The Momentum of Out of Time Tracks",1000,0.0,7.0); - TrackMomentumAllTime1_ = new TH1F("TrackMomentumAll","The Momentum of All Tracks",1000,0.0,7.0); - - TrackMomentumTInTime1_ = new TH1F("TrackMomentumTInTime","The Transverse Momentum of In Time Tracks",1000,0.0,7.0); - TrackMomentumTOutTime1_ = new TH1F("TrackMomentumTOutTime","The Transverse Momentum of Out of Time Tracks",1000,0.0,7.0); - TrackMomentumTAllTime1_ = new TH1F("TrackMomentumTAll","The Transverse Momentum of All Tracks",1000,0.0,7.0); + if (doingTracks_){ + Z0VNShare2Hist1_ = new TH2F("Z0VNShare2Hist", "Z0 versus Number of Shared Hits No Cut", 100, 0, 3, 8, 0, 8); + Z0VNShare2HistCut1_ = new TH2F("Z0VNShare2HistCut", "Z0 versus Number of Shared Hits Momentum Cut", 100, 0, 3, 8, 0, 8); + SharedAmplitudes1_ = new TH1F("SharedAmplitudes", "The Amplitudes of Clusters Shared Between Tracks", 1000, 0.0, 0.000016); + UnSharedAmplitudes1_ = new TH1F("UnSharedAmplitudes", "The Amplitudes of Clusters Not Shared Between Tracks", 1000, 0.0, 0.000016); + SharedTimes1_ = new TH1F("SharedTimes", "The Times of Clusters Shared Between Tracks", 1000, -60.0, 60.0); + UnSharedTimes1_ = new TH1F("UnSharedTimes", "The Times of Clusters Not Shared Between Tracks", 1000, -60.0, 60.0); + TrackMomentumInTime1_ = new TH1F("TrackMomentumInTime", "The Momentum of In Time Tracks", 1000, 0.0, 7.0); + TrackMomentumOutTime1_ = new TH1F("TrackMomentumOutTime", "The Momentum of Out of Time Tracks", 1000, 0.0, 7.0); + TrackMomentumAllTime1_ = new TH1F("TrackMomentumAll", "The Momentum of All Tracks", 1000, 0.0, 7.0); + + TrackMomentumTInTime1_ = new TH1F("TrackMomentumTInTime", "The Transverse Momentum of In Time Tracks", 1000, 0.0, 7.0); + TrackMomentumTOutTime1_ = new TH1F("TrackMomentumTOutTime", "The Transverse Momentum of Out of Time Tracks", 1000, 0.0, 7.0); + TrackMomentumTAllTime1_ = new TH1F("TrackMomentumTAll", "The Transverse Momentum of All Tracks", 1000, 0.0, 7.0); } - //Instantiating the first layer - - layers2_=new TH1F("layers","Strip Width for All Clusters",12,0.0,12.0); - layersOnTrk2_=new TH1F("layersOnTrk","Strip Width for Clusters on Track",12,0.0,12.0); - layersOffTrk2_=new TH1F("layersOffTrk","Strip Width for Clusters off Track",12,0.0,12.0); - charges2_=new TH1F("charges","Charge Distribution for All Clusters",1000,0.0,0.000016); - chargesOnTrk2_=new TH1F("chargesOnTrk","Charge Distribution for On Track",1000,0.0,.000016); - chargesOffTrk2_=new TH1F("chargesOffTrk","Charge Distribution for Off Track",1000,0.0,0.000016); - - layersNTD2_=new TH1F("layersNTD","Strip Width for All Clusters",12,0.0,12.0); - layersOnTrkNTD2_=new TH1F("layersOnTrkNTD","Strip Width for Clusters on Track",12,0.0,12.0); - layersOffTrkNTD2_=new TH1F("layersOffTrkNTD","Strip Width for Clusters off Track",12,0.0,12.0); - chargesNTD2_=new TH1F("chargesNTD","Charge Distribution for All Clusters",1000,0.0,0.000016); - chargesOnTrkNTD2_=new TH1F("chargesOnTrkNTD","Charge Distribution for On Track",1000,0.0,.000016); - chargesOffTrkNTD2_=new TH1F("chargesOffTrkNTD","Charge Distribution for Off Track",1000,0.0,0.000016); - - times2_=new TH1F("Times","Time of Cluster Hit",1000,-60.0,60.0); - timesOnTrk2_=new TH1F("TimesOnTrk","Time of On Track Cluster Hit",1000,-60.0,60.0); - timesOffTrk2_=new TH1F("TimesOffTrk","Time of Off Cluster Hit",1000,-60.0,60.0); - timesNTD2_=new TH1F("TimesNTD","Time of Cluster Hit NTD",1000,-60.0,60.0); - timesOnTrkNTD2_=new TH1F("TimesOnTrkNTD","Time of On Track Cluster Hit NTD",1000,-60.0,60.0); - timesOffTrkNTD2_=new TH1F("TimesOffTrkNTD","Time of Off Cluster Hit NTD",1000,-60.0,60.0); + // Instantiating the second layer + layers2_ = new TH1F("layers", "Strip Width for All Clusters", 12, 0.0, 12.0); + layersOnTrk2_ = new TH1F("layersOnTrk", "Strip Width for Clusters on Track", 12, 0.0, 12.0); + layersOffTrk2_ = new TH1F("layersOffTrk", "Strip Width for Clusters off Track", 12, 0.0, 12.0); + charges2_ = new TH1F("charges", "Charge Distribution for All Clusters", 1000, 0.0, 0.000016); + chargesOnTrk2_ = new TH1F("chargesOnTrk", "Charge Distribution for On Track", 1000, 0.0, 0.000016); + chargesOffTrk2_ = new TH1F("chargesOffTrk", "Charge Distribution for Off Track", 1000, 0.0, 0.000016); + + layersNTD2_ = new TH1F("layersNTD", "Strip Width for All Clusters", 12, 0.0, 12.0); + layersOnTrkNTD2_ = new TH1F("layersOnTrkNTD", "Strip Width for Clusters on Track", 12, 0.0, 12.0); + layersOffTrkNTD2_ = new TH1F("layersOffTrkNTD", "Strip Width for Clusters off Track", 12, 0.0, 12.0); + chargesNTD2_ = new TH1F("chargesNTD", "Charge Distribution for All Clusters", 1000, 0.0, 0.000016); + chargesOnTrkNTD2_ = new TH1F("chargesOnTrkNTD", "Charge Distribution for On Track", 1000, 0.0, 0.000016); + chargesOffTrkNTD2_ = new TH1F("chargesOffTrkNTD", "Charge Distribution for Off Track", 1000, 0.0, 0.000016); + + times2_ = new TH1F("Times", "Time of Cluster Hit", 1000, -60.0, 60.0); + timesOnTrk2_ = new TH1F("TimesOnTrk", "Time of On Track Cluster Hit", 1000, -60.0, 60.0); + timesOffTrk2_ = new TH1F("TimesOffTrk", "Time of Off Cluster Hit", 1000, -60.0, 60.0); + timesNTD2_ = new TH1F("TimesNTD", "Time of Cluster Hit NTD", 1000, -60.0, 60.0); + timesOnTrkNTD2_ = new TH1F("TimesOnTrkNTD", "Time of On Track Cluster Hit NTD", 1000, -60.0, 60.0); + timesOffTrkNTD2_ = new TH1F("TimesOffTrkNTD", "Time of Off Cluster Hit NTD", 1000, -60.0, 60.0); - positions2_=new TH1F("Positions","Location of Cluster Hit;Layer;Hits",14,0.0,14.0); - positionsOnTrk2_=new TH1F("PositionsOnTrk","Location of Cluster Hit for On Track",14,0.0,14.0); - ClusDistances2_=new TH1F("Minimum Cluster Difference","Minimum Distance Between Clusters",14,0.0,14.0); - ClusDistancesNTD2_=new TH1F("Minimum Cluster Difference","Minimum Distance Between Clusters",14,0.0,14.0); - - if(doingTracks_){ - Z0VNShare2Hist2_= new TH2F("Z0VNShare2Hist","Z0 versus Number of Shared Hits No Cut",100,0,3,8,0,8); - Z0VNShare2HistCut2_= new TH2F("Z0VNShare2HistCut","Z0 versus Number of Shared Hits Momentum Cut",100,0,3,8,0,8); - SharedAmplitudes2_= new TH1F("SharedAmplitudes","The Amplitudes of Clusters Shared Between Tracks",1000,0.0,0.000016); - UnSharedAmplitudes2_= new TH1F("UnSharedAmplitudes","The Amplitudes of Clusters Not Shared Between Tracks",1000,0.0,0.000016); - SharedTimes2_= new TH1F("SharedTimes","The Times of Clusters Shared Between Tracks",1000,-60.0,60.0); - UnSharedTimes2_= new TH1F("UnSharedTimes","The Times of Clusters Not Shared Between Tracks",1000,-60.0,60.0); + positions2_ = new TH1F("Positions", "Location of Cluster Hit;Layer;Hits", 14, 0.0, 14.0); + positionsOnTrk2_ = new TH1F("PositionsOnTrk", "Location of Cluster Hit for On Track", 14, 0.0, 14.0); + ClusDistances2_ = new TH1F("Minimum Cluster Difference", "Minimum Distance Between Clusters", 14, 0.0, 14.0); + ClusDistancesNTD2_ = new TH1F("Minimum Cluster Difference", "Minimum Distance Between Clusters", 14, 0.0, 14.0); + + if (doingTracks_){ + Z0VNShare2Hist2_ = new TH2F("Z0VNShare2Hist", "Z0 versus Number of Shared Hits No Cut", 100, 0, 3, 8, 0, 8); + Z0VNShare2HistCut2_ = new TH2F("Z0VNShare2HistCut", "Z0 versus Number of Shared Hits Momentum Cut", 100, 0, 3, 8, 0, 8); + SharedAmplitudes2_ = new TH1F("SharedAmplitudes", "The Amplitudes of Clusters Shared Between Tracks", 1000, 0.0, 0.000016); + UnSharedAmplitudes2_ = new TH1F("UnSharedAmplitudes", "The Amplitudes of Clusters Not Shared Between Tracks", 1000, 0.0, 0.000016); + SharedTimes2_ = new TH1F("SharedTimes", "The Times of Clusters Shared Between Tracks", 1000, -60.0, 60.0); + UnSharedTimes2_ = new TH1F("UnSharedTimes", "The Times of Clusters Not Shared Between Tracks", 1000, -60.0, 60.0); - TrackMomentumInTime2_ = new TH1F("TrackMomentumInTime","The Momentum of In Time Tracks",1000,0.0,7.0); - TrackMomentumOutTime2_ = new TH1F("TrackMomentumOutTime","The Momentum of Out of Time Tracks",1000,0.0,7.0); - TrackMomentumAllTime2_ = new TH1F("TrackMomentumAll","The Momentum of All Tracks",1000,0.0,7.0); + TrackMomentumInTime2_ = new TH1F("TrackMomentumInTime", "The Momentum of In Time Tracks", 1000, 0.0, 7.0); + TrackMomentumOutTime2_ = new TH1F("TrackMomentumOutTime", "The Momentum of Out of Time Tracks", 1000, 0.0, 7.0); + TrackMomentumAllTime2_ = new TH1F("TrackMomentumAll", "The Momentum of All Tracks", 1000, 0.0, 7.0); - TrackMomentumTInTime2_ = new TH1F("TrackMomentumTInTime","The Transverse Momentum of In Time Tracks",1000,0.0,7.0); - TrackMomentumTOutTime2_ = new TH1F("TrackMomentumTOutTime","The Transverse Momentum of Out of Time Tracks",1000,0.0,7.0); - TrackMomentumTAllTime2_ = new TH1F("TrackMomentumTAll","The Transverse Momentum of All Tracks",1000,0.0,7.0); + TrackMomentumTInTime2_ = new TH1F("TrackMomentumTInTime", "The Transverse Momentum of In Time Tracks", 1000, 0.0, 7.0); + TrackMomentumTOutTime2_ = new TH1F("TrackMomentumTOutTime", "The Transverse Momentum of Out of Time Tracks", 1000, 0.0, 7.0); + TrackMomentumTAllTime2_ = new TH1F("TrackMomentumTAll", "The Transverse Momentum of All Tracks", 1000, 0.0, 7.0); } - tree_->SetBranchAddress("SiClusters",&Clusters_,&bClusters_); - tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); - tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); - tree_->SetBranchAddress("Identifier",&ident_,&bident_); - if(doingTracks_){ - tree_->SetBranchAddress("KalmanFullTracks",&tracks_,&btracks_); + tree_->SetBranchAddress("SiClusters", &Clusters_, &bClusters_); + tree_->SetBranchAddress("SiClustersOnTrack_KF", &ClustersKF_, &bClustersKF_); + tree_->SetBranchAddress("SVTRawTrackerHits", &svtraw_, &bsvtraw_); + tree_->SetBranchAddress("Identifier", &ident_, &bident_); + if (doingTracks_){ + tree_->SetBranchAddress("KalmanFullTracks", &tracks_, &btracks_); } } bool TrackHitAnaProcessor::process(IEvent* ievent) { - if(doingTracks_){ - for(int i = 0;isize();i++){ + if (doingTracks_){ + for (int i = 0; isize(); i++){ Track* track = tracks_->at(i); - if(track->getTrackTime()*track->getTrackTime()<100.0){ - if(ident_<1.5){Z0VNShare2Hist1_->Fill(track->getZ0Err(),track->getNShared());}else{Z0VNShare2Hist2_->Fill(track->getZ0Err(),track->getNShared());} - if(track->getP()Fill(track->getZ0Err(),track->getNShared());}else{Z0VNShare2HistCut2_->Fill(track->getZ0Err(),track->getNShared());} + if (track->getTrackTime()*track->getTrackTime()<100.0){ + if (ident_ < 1.5){ + Z0VNShare2Hist1_->Fill(track->getZ0Err(), track->getNShared()); + } else { + Z0VNShare2Hist2_->Fill(track->getZ0Err(), track->getNShared()); + } + if (track->getP()Fill(track->getZ0Err(), track->getNShared()); + } else { + Z0VNShare2HistCut2_->Fill(track->getZ0Err(), track->getNShared()); + } } } - //Track Momentum for In and Out of time hits (All not just transverse) - if(ident_<1.5){TrackMomentumAllTime1_->Fill(track->getP());}else{TrackMomentumAllTime2_->Fill(track->getP());} + // Track Momentum for In and Out of time hits (All not just transverse) + if (ident_ < 1.5) { + TrackMomentumAllTime1_->Fill(track->getP()); + } else { + TrackMomentumAllTime2_->Fill(track->getP()); + } - if(track->getTrackTime()*track->getTrackTime()<16.0){ - if(ident_<1.5){TrackMomentumInTime1_->Fill(track->getP());}else{TrackMomentumInTime2_->Fill(track->getP());} - }else{ - if(ident_<1.5){TrackMomentumOutTime1_->Fill(track->getP());}else{TrackMomentumOutTime2_->Fill(track->getP());} + if (track->getTrackTime()*track->getTrackTime() < 16.0){ + if (ident_ < 1.5){ + TrackMomentumInTime1_->Fill(track->getP()); + } else { + TrackMomentumInTime2_->Fill(track->getP()); + } + } else { + if (ident_ < 1.5) { + TrackMomentumOutTime1_->Fill(track->getP()); + } else { + TrackMomentumOutTime2_->Fill(track->getP()); + } } - //Transverse Track Momentum for same cuts - if(ident_<1.5){TrackMomentumTAllTime1_->Fill(track->getPt());}else{TrackMomentumTAllTime2_->Fill(track->getPt());} + // Transverse Track Momentum for same cuts + if (ident_ < 1.5){ + TrackMomentumTAllTime1_->Fill(track->getPt()); + } else { + TrackMomentumTAllTime2_->Fill(track->getPt()); + } - if(track->getTrackTime()*track->getTrackTime()<16.0){ - if(ident_<1.5){TrackMomentumTInTime1_->Fill(track->getPt());}else{TrackMomentumTInTime2_->Fill(track->getPt());} - }else{ - if(ident_<1.5){TrackMomentumTOutTime1_->Fill(track->getPt());}else{TrackMomentumTOutTime2_->Fill(track->getPt());} + if (track->getTrackTime()*track->getTrackTime() < 16.0){ + if (ident_ < 1.5){ + TrackMomentumTInTime1_->Fill(track->getPt()); + } else { + TrackMomentumTInTime2_->Fill(track->getPt()); + } + } else { + if (ident_ < 1.5){ + TrackMomentumTOutTime1_->Fill(track->getPt()); + } else { + TrackMomentumTOutTime2_->Fill(track->getPt()); + } } } } @@ -203,107 +234,171 @@ bool TrackHitAnaProcessor::process(IEvent* ievent) { RawSvtHit * seed = (RawSvtHit*)(clu->getRawHits().At(0)); - layc=clu->getLayer(); - modc=seed->getModule(); + layc = clu->getLayer(); + modc = seed->getModule(); - if(doingTracks_){ - bool isShared = false;int increment = 0; - for(int i = 0;isize();i++){ + if (doingTracks_){ + bool isShared = false; + int increment = 0; + for (int i = 0; isize(); i++){ Track* track = tracks_->at(i); - for(int j = 0; jgetSvtHits().GetEntries();j++){ + for (int j = 0; jgetSvtHits().GetEntries(); j++){ TrackerHit * test = (TrackerHit *)(track->getSvtHits().At(j)); - if(clu->getTime()==test->getTime()){ + if (clu->getTime()==test->getTime()){ increment+=1; } } } - if(increment>1){ - isShared=true; + if (increment > 1){ + isShared = true; } - if(increment>0){ + if (increment > 0){ bool general = ((layer_==-1)||(module_==-1)); - if(((layc==layer_)&&(modc==module_))||(general)){ - if(isShared){ - if(ident_<1.5){SharedAmplitudes1_->Fill(clu->getCharge());}else{SharedAmplitudes2_->Fill(clu->getCharge());} - if(ident_<1.5){SharedTimes1_->Fill(clu->getTime());}else{SharedTimes2_->Fill(clu->getTime());} - }else{ - if(ident_<1.5){UnSharedAmplitudes1_->Fill(clu->getCharge());}else{UnSharedAmplitudes2_->Fill(clu->getCharge());} - if(ident_<1.5){UnSharedTimes1_->Fill(clu->getTime());}else{UnSharedTimes2_->Fill(clu->getTime());} + if (((layc==layer_)&&(modc==module_))||(general)){ + if (isShared){ + if (ident_ < 1.5){ + SharedAmplitudes1_->Fill(clu->getCharge()); + } else { + SharedAmplitudes2_->Fill(clu->getCharge()); + } + if (ident_ < 1.5){ + SharedTimes1_->Fill(clu->getTime()); + } else { + SharedTimes2_->Fill(clu->getTime()); + } + } else { + if (ident_ < 1.5){ + UnSharedAmplitudes1_->Fill(clu->getCharge()); + } else { + UnSharedAmplitudes2_->Fill(clu->getCharge()); + } + if (ident_ < 1.5){ + UnSharedTimes1_->Fill(clu->getTime()); + } else { + UnSharedTimes2_->Fill(clu->getTime()); + } } } } } - - + float seedStrip = (float)(seed->getStrip()); float nLayers = (float)(clu->getRawHits().GetEntries()); float ncharges = (float)(clu->getCharge()); float ntimes = (float)(clu->getTime()); bool onTrk = false; bool NTD = false; - for(unsigned int j = 0; j < ClustersKF_->size(); j++){ - if(clu->getID()==(ClustersKF_->at(j)->getID())){ + for (unsigned int j = 0; j < ClustersKF_->size(); j++){ + if (clu->getID()==(ClustersKF_->at(j)->getID())){ onTrk = true; } } - std::string input = "ly"+std::to_string(layc+1)+"_m"+std::to_string(modc); + std::string input = "ly" + std::to_string(layc+1) + "_m" + std::to_string(modc); std::string helper = mmapper_->getHwFromSw(input); - int feb=std::stoi(helper.substr(1,1)); - int hyb=std::stoi(helper.substr(3,1)); + int feb = std::stoi(helper.substr(1, 1)); + int hyb = std::stoi(helper.substr(3, 1)); - int channelL=seedStrip-1; - int channelR=seedStrip+1; - if(channelL>=0){ - NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelL)]==1); + int channelL = seedStrip-1; + int channelR = seedStrip+1; + if (channelL >= 0){ + NTD = (NTD)||(Deads_[GetStrip(feb, hyb, channelL)]==1); } - if(((feb<=1)&&(channelR<=511))||((feb>1)&&(channelR<=639))){ - NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelR)]==1); + if (((feb<=1)&&(channelR<=511))||((feb>1)&&(channelR<=639))){ + NTD = (NTD)||(Deads_[GetStrip(feb, hyb, channelR)]==1); } bool general = ((layer_==-1)||(module_==-1)); - if(((layc==layer_)&&(modc==module_))||(general)){ - //NOW IS THE PART WHERE I FILL THE CLUSTER DISTANCE HISTOGRAM - float Dist=69420; - for(int p = 0; p < Clusters_->size(); p++){ - if(p==i){continue;} + if (((layc==layer_)&&(modc==module_))||(general)){ + // Now is the part where I fill the cluster distance histogram + float dist = 69420; + for (int p = 0; p < Clusters_->size(); p++){ + if (p==i) { continue; } TrackerHit * clu2 = Clusters_->at(p); RawSvtHit * seed2 = (RawSvtHit*)(clu2->getRawHits().At(0)); - float layc2=clu->getLayer(); - float modc2=seed->getModule(); - if((not(layc2==layc))or(not(modc2==modc))){continue;} - float dist = ((float)(seed2->getStrip()))-seedStrip; - if(dist<0){dist*=-1.0;} - if(distgetLayer(); + float modc2 = seed->getModule(); + if ((!(layc2==layc))||(!(modc2==modc))) { continue; } + float new_dist = ((float)(seed2->getStrip())) - seedStrip; + if (new_dist < 0){ new_dist *= -1.0; } + if (new_dist < dist){ dist = new_dist; } + } + if (dist < 69420){ + if (ident_ < 1.5){ + ClusDistances1_->Fill(dist); + } else { + ClusDistances2_->Fill(dist); + } + if (NTD){ + if (ident_ < 1.5){ + ClusDistancesNTD1_->Fill(dist); + } else { + ClusDistancesNTD2_->Fill(dist); + } + } } - if(Dist<69420){ - if(ident_<1.5){ClusDistances1_->Fill(Dist);}else{ClusDistances2_->Fill(Dist);} - if(NTD){if(ident_<1.5){ClusDistancesNTD1_->Fill(Dist);}else{ClusDistancesNTD2_->Fill(Dist);}} + if (ident_ < 1.5){ + layers1_->Fill(nLayers); + charges1_->Fill(ncharges); + positions1_->Fill(clu->getLayer()); + times1_->Fill(ntimes); + } else { + layers2_->Fill(nLayers); + charges2_->Fill(ncharges); + positions2_->Fill(clu->getLayer()); + times2_->Fill(ntimes); } - if(ident_<1.5){layers1_->Fill(nLayers);}else{layers2_->Fill(nLayers);} - if(ident_<1.5){charges1_->Fill(ncharges);}else{charges2_->Fill(ncharges);} - if(ident_<1.5){positions1_->Fill(clu->getLayer());}else{positions2_->Fill(clu->getLayer());} - if(ident_<1.5){times1_->Fill(ntimes);}else{times2_->Fill(ntimes);} - if(onTrk){ - if(ident_<1.5){layersOnTrk1_->Fill(nLayers);}else{layersOnTrk2_->Fill(nLayers);} - if(ident_<1.5){chargesOnTrk1_->Fill(ncharges);}else{chargesOnTrk2_->Fill(ncharges);} - if(ident_<1.5){timesOnTrk1_->Fill(ntimes);}else{timesOnTrk2_->Fill(ntimes);} - if(ident_<1.5){positionsOnTrk1_->Fill(clu->getLayer());}else{positionsOnTrk2_->Fill(clu->getLayer());} - }else{ - if(ident_<1.5){layersOffTrk1_->Fill(nLayers);}else{layersOffTrk2_->Fill(nLayers);} - if(ident_<1.5){chargesOffTrk1_->Fill(ncharges);}else{chargesOffTrk2_->Fill(ncharges);} - if(ident_<1.5){timesOffTrk1_->Fill(ntimes);}else{timesOffTrk2_->Fill(ntimes);} + if (onTrk){ + if (ident_ < 1.5){ + layersOnTrk1_->Fill(nLayers); + chargesOnTrk1_->Fill(ncharges); + timesOnTrk1_->Fill(ntimes); + positionsOnTrk1_->Fill(clu->getLayer()); + } else { + layersOnTrk2_->Fill(nLayers); + chargesOnTrk2_->Fill(ncharges); + timesOnTrk2_->Fill(ntimes); + positionsOnTrk2_->Fill(clu->getLayer()); + } + } else { + if (ident_ < 1.5){ + layersOffTrk1_->Fill(nLayers); + chargesOffTrk1_->Fill(ncharges); + timesOffTrk1_->Fill(ntimes); + } else { + layersOffTrk2_->Fill(nLayers); + chargesOffTrk2_->Fill(ncharges); + timesOffTrk2_->Fill(ntimes); + } } - if(NTD){ - if(ident_<1.5){layersNTD1_->Fill(nLayers);}else{layersNTD2_->Fill(nLayers);} - if(ident_<1.5){chargesNTD1_->Fill(ncharges);}else{chargesNTD2_->Fill(ncharges);} - if(ident_<1.5){timesNTD1_->Fill(ntimes);}else{timesNTD2_->Fill(ntimes);} - if(onTrk){ - if(ident_<1.5){layersOnTrkNTD1_->Fill(nLayers);}else{layersOnTrkNTD2_->Fill(nLayers);} - if(ident_<1.5){chargesOnTrkNTD1_->Fill(ncharges);}else{chargesOnTrkNTD2_->Fill(ncharges);} - if(ident_<1.5){timesOnTrkNTD1_->Fill(ntimes);}else{timesOnTrkNTD2_->Fill(ntimes);} - }else{ - if(ident_<1.5){layersOffTrkNTD1_->Fill(nLayers);}else{layersOffTrkNTD2_->Fill(nLayers);} - if(ident_<1.5){chargesOffTrkNTD1_->Fill(ncharges);}else{chargesOffTrkNTD2_->Fill(ncharges);} - if(ident_<1.5){timesOffTrkNTD1_->Fill(ntimes);}else{timesOffTrkNTD2_->Fill(ntimes);} + if (NTD){ + if (ident_ < 1.5){ + layersNTD1_->Fill(nLayers); + chargesNTD1_->Fill(ncharges); + timesNTD1_->Fill(ntimes); + } else { + layersNTD2_->Fill(nLayers); + chargesNTD2_->Fill(ncharges); + timesNTD2_->Fill(ntimes); + } + if (onTrk){ + if (ident_ < 1.5){ + layersOnTrkNTD1_->Fill(nLayers); + chargesOnTrkNTD1_->Fill(ncharges); + timesOnTrkNTD1_->Fill(ntimes); + } else { + layersOnTrkNTD2_->Fill(nLayers); + chargesOnTrkNTD2_->Fill(ncharges); + timesOnTrkNTD2_->Fill(ntimes); + } + } else { + if (ident_ < 1.5){ + layersOffTrkNTD1_->Fill(nLayers); + chargesOffTrkNTD1_->Fill(ncharges); + timesOffTrkNTD1_->Fill(ntimes); + } else { + layersOffTrkNTD2_->Fill(nLayers); + chargesOffTrkNTD2_->Fill(ncharges); + timesOffTrkNTD2_->Fill(ntimes); + } } } } @@ -312,30 +407,30 @@ bool TrackHitAnaProcessor::process(IEvent* ievent) { } void TrackHitAnaProcessor::fillDeads(){ - for(int i = 0;i<24576;i++){ + for (int i = 0; i<24576; i++){ Deads_[i]=0.0; } - std::string FILENAME=badchann_; + std::string FILENAME = badchann_; std::ifstream file(FILENAME.c_str()); std::string line; - std::getline(file,line); + std::getline(file, line); while (std::getline(file, line)) { int value = std::atoi(line.c_str()); - Deads_[value]=1.0; + Deads_[value] = 1.0; } file.close(); return; } -int TrackHitAnaProcessor::GetStrip(int feb,int hyb,int strip){ - int BigCount = 0; - if(feb<=1){ - BigCount+=feb*2048+hyb*512+strip; - }else{ - BigCount+=4096; - BigCount+=(feb-2)*2560+hyb*640+strip; +int TrackHitAnaProcessor::GetStrip(int feb, int hyb, int strip){ + int count = 0; + if (feb <= 1){ + count += feb*2048 + hyb*512 + strip; + } else { + count += 4096; + count += (feb-2)*2560 + hyb*640 + strip; } - return BigCount; + return count; } void TrackHitAnaProcessor::PlotClusterLayers(){ @@ -363,13 +458,13 @@ void TrackHitAnaProcessor::PlotClusterLayers(){ layersOnTrk2_->SetLineColor(kBlue); layersOffTrk2_->SetLineColor(kBlue); - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle("Layers for All Clusters"); layers1_->Draw("e"); layers2_->Draw("e same"); - auto legend1 = new TLegend(0.3,0.8,.68,.9); - legend1->AddEntry(layers1_,"Layers Rec 1"); - legend1->AddEntry(layers2_,"Layers Rec 2"); + auto legend1 = new TLegend(0.3, 0.8, .68, .9); + legend1->AddEntry(layers1_, "Layers Rec 1"); + legend1->AddEntry(layers2_, "Layers Rec 2"); legend1->Draw("same e"); c1->SaveAs("allClusters.png"); c1->Clear(); @@ -377,9 +472,9 @@ void TrackHitAnaProcessor::PlotClusterLayers(){ c1->SetTitle("Layers for On Track Clusters"); layersOnTrk1_->Draw("e"); layersOnTrk2_->Draw("e same"); - auto legend2 = new TLegend(0.3,0.8,.68,.9); - legend2->AddEntry(layersOnTrk1_,"Layers On Track Rec 1"); - legend2->AddEntry(layersOnTrk2_,"Layers On Track Rec 2"); + auto legend2 = new TLegend(0.3, 0.8, .68, .9); + legend2->AddEntry(layersOnTrk1_, "Layers On Track Rec 1"); + legend2->AddEntry(layersOnTrk2_, "Layers On Track Rec 2"); legend2->Draw("same e"); c1->SaveAs("onClusters.png"); c1->Clear(); @@ -387,9 +482,9 @@ void TrackHitAnaProcessor::PlotClusterLayers(){ c1->SetTitle("Layers for Off Track Clusters"); layersOffTrk1_->Draw("e"); layersOffTrk2_->Draw("e same"); - auto legend3 = new TLegend(0.3,0.8,.68,.9); - legend3->AddEntry(layersOffTrk1_,"Layers Off Track Rec 1"); - legend3->AddEntry(layersOffTrk2_,"Layers Off Track Rec 2"); + auto legend3 = new TLegend(0.3, 0.8, .68, .9); + legend3->AddEntry(layersOffTrk1_, "Layers Off Track Rec 1"); + legend3->AddEntry(layersOffTrk2_, "Layers Off Track Rec 2"); legend3->Draw("same e"); c1->SaveAs("offClusters.png"); c1->Clear(); @@ -420,14 +515,13 @@ void TrackHitAnaProcessor::PlotClusterCharges(){ chargesOnTrk2_->SetLineColor(kBlue); chargesOffTrk2_->SetLineColor(kBlue); - - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle("Charges for All Clusters"); charges1_->Draw("e"); charges2_->Draw("e same"); - auto legend1 = new TLegend(0.3,0.8,.68,.9); - legend1->AddEntry(charges1_,"Charges Rec 1"); - legend1->AddEntry(charges2_,"Charges Rec 2"); + auto legend1 = new TLegend(0.3, 0.8, .68, .9); + legend1->AddEntry(charges1_, "Charges Rec 1"); + legend1->AddEntry(charges2_, "Charges Rec 2"); legend1->Draw("same e"); c1->SaveAs("allClustersCharge.png"); c1->Clear(); @@ -435,9 +529,9 @@ void TrackHitAnaProcessor::PlotClusterCharges(){ c1->SetTitle("Charges for On Track Clusters"); chargesOnTrk1_->Draw("e"); chargesOnTrk2_->Draw("e same"); - auto legend2 = new TLegend(0.3,0.8,.68,.9); - legend2->AddEntry(chargesOnTrk1_,"Charges On Track Rec 1"); - legend2->AddEntry(chargesOnTrk2_,"Charges On Track Rec 2"); + auto legend2 = new TLegend(0.3, 0.8, .68, .9); + legend2->AddEntry(chargesOnTrk1_, "Charges On Track Rec 1"); + legend2->AddEntry(chargesOnTrk2_, "Charges On Track Rec 2"); legend2->Draw("same e"); c1->SaveAs("onClustersCharge.png"); c1->Clear(); @@ -445,9 +539,9 @@ void TrackHitAnaProcessor::PlotClusterCharges(){ c1->SetTitle("Charges for Off Track Clusters"); chargesOffTrk1_->Draw("e"); chargesOffTrk2_->Draw("e same"); - auto legend3 = new TLegend(0.3,0.8,.68,.9); - legend3->AddEntry(chargesOffTrk1_,"Charges Off Track Rec 1"); - legend3->AddEntry(chargesOffTrk2_,"Charges Off Track Rec 2"); + auto legend3 = new TLegend(0.3, 0.8, .68, .9); + legend3->AddEntry(chargesOffTrk1_, "Charges Off Track Rec 1"); + legend3->AddEntry(chargesOffTrk2_, "Charges Off Track Rec 2"); legend3->Draw("same e"); c1->SaveAs("offClustersCharge.png"); c1->Clear(); @@ -468,7 +562,6 @@ void TrackHitAnaProcessor::PlotClusterTimes(){ timesOnTrk1_->SetLineColor(kRed); timesOffTrk1_->SetLineColor(kRed); - times2_->GetXaxis()->SetTitle("Charge"); times2_->GetYaxis()->SetTitle("Hits"); timesOffTrk2_->GetXaxis()->SetTitle("Charge"); @@ -479,14 +572,13 @@ void TrackHitAnaProcessor::PlotClusterTimes(){ timesOnTrk2_->SetLineColor(kBlue); timesOffTrk2_->SetLineColor(kBlue); - - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle("Times for All Clusters"); times1_->Draw("e"); times2_->Draw("e same"); - auto legend1 = new TLegend(0.3,0.8,.68,.9); - legend1->AddEntry(times1_,"Times Rec 1"); - legend1->AddEntry(times2_,"Times Rec 2"); + auto legend1 = new TLegend(0.3, 0.8, .68, .9); + legend1->AddEntry(times1_, "Times Rec 1"); + legend1->AddEntry(times2_, "Times Rec 2"); legend1->Draw("same e"); c1->SaveAs("alltimes.png"); c1->Clear(); @@ -494,9 +586,9 @@ void TrackHitAnaProcessor::PlotClusterTimes(){ c1->SetTitle("Times for On Track Clusters"); timesOnTrk1_->Draw("e"); timesOnTrk2_->Draw("e same"); - auto legend2 = new TLegend(0.3,0.8,.68,.9); - legend2->AddEntry(timesOnTrk1_,"Times On Track Rec 1"); - legend2->AddEntry(timesOnTrk2_,"Times On Track Rec 2"); + auto legend2 = new TLegend(0.3, 0.8, .68, .9); + legend2->AddEntry(timesOnTrk1_, "Times On Track Rec 1"); + legend2->AddEntry(timesOnTrk2_, "Times On Track Rec 2"); legend2->Draw("same e"); c1->SaveAs("ontimes.png"); c1->Clear(); @@ -504,9 +596,9 @@ void TrackHitAnaProcessor::PlotClusterTimes(){ c1->SetTitle("Times for Off Track Clusters"); timesOffTrk1_->Draw("e"); timesOffTrk2_->Draw("e same"); - auto legend3 = new TLegend(0.3,0.8,.68,.9); - legend3->AddEntry(timesOffTrk1_,"Times Off Track Rec 1"); - legend3->AddEntry(timesOffTrk2_,"Times Off Track Rec 2"); + auto legend3 = new TLegend(0.3, 0.8, .68, .9); + legend3->AddEntry(timesOffTrk1_, "Times Off Track Rec 1"); + legend3->AddEntry(timesOffTrk2_, "Times Off Track Rec 2"); legend3->Draw("same e"); c1->SaveAs("offtimes.png"); c1->Clear(); @@ -532,14 +624,13 @@ void TrackHitAnaProcessor::PlotClusterPositions(){ positions2_->SetLineColor(kBlue); positionsOnTrk2_->SetLineColor(kBlue); - - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle("Position for All Clusters"); positions1_->Draw("e"); positions2_->Draw("e same"); - auto legend1 = new TLegend(0.3,0.8,.68,.9); - legend1->AddEntry(positions1_,"Position Rec 1"); - legend1->AddEntry(positions2_,"Position Rec 2"); + auto legend1 = new TLegend(0.3, 0.8, .68, .9); + legend1->AddEntry(positions1_, "Position Rec 1"); + legend1->AddEntry(positions2_, "Position Rec 2"); legend1->Draw("same e"); c1->SaveAs("positions.png"); c1->Clear(); @@ -547,9 +638,9 @@ void TrackHitAnaProcessor::PlotClusterPositions(){ c1->SetTitle("Position for On Track Clusters"); positionsOnTrk1_->Draw("e"); positionsOnTrk2_->Draw("e same"); - auto legend2 = new TLegend(0.3,0.8,.68,.9); - legend2->AddEntry(positionsOnTrk1_,"Position On Track Rec 1"); - legend2->AddEntry(positionsOnTrk2_,"Position On Track Rec 2"); + auto legend2 = new TLegend(0.3, 0.8, .68, .9); + legend2->AddEntry(positionsOnTrk1_, "Position On Track Rec 1"); + legend2->AddEntry(positionsOnTrk2_, "Position On Track Rec 2"); legend2->Draw("same e"); c1->SaveAs("onpositions.png"); c1->Clear(); @@ -557,9 +648,9 @@ void TrackHitAnaProcessor::PlotClusterPositions(){ c1->SetTitle("Cluster Distances"); positionsOnTrk1_->Draw("e"); positionsOnTrk2_->Draw("e same"); - auto legend3 = new TLegend(0.3,0.8,.68,.9); - legend3->AddEntry(positionsOnTrk1_,"Cluster Distances Rec 1"); - legend3->AddEntry(positionsOnTrk2_,"Cluster Distances Rec 2"); + auto legend3 = new TLegend(0.3, 0.8, .68, .9); + legend3->AddEntry(positionsOnTrk1_, "Cluster Distances Rec 1"); + legend3->AddEntry(positionsOnTrk2_, "Cluster Distances Rec 2"); legend3->Draw("same e"); c1->SaveAs("clusDistances.png"); c1->Clear(); @@ -585,13 +676,13 @@ void TrackHitAnaProcessor::TrackMomenta(){ TrackMomentumInTime2_->SetLineColor(kBlue); TrackMomentumOutTime2_->SetLineColor(kBlue); - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle("Momentum for All Tracks"); TrackMomentumAllTime1_->Draw("e"); TrackMomentumAllTime2_->Draw("e same"); - auto legend1 = new TLegend(0.3,0.8,.68,.9); - legend1->AddEntry(TrackMomentumAllTime1_,"Momenta Rec 1"); - legend1->AddEntry(TrackMomentumAllTime2_,"Momenta Rec 2"); + auto legend1 = new TLegend(0.3, 0.8, .68, .9); + legend1->AddEntry(TrackMomentumAllTime1_, "Momenta Rec 1"); + legend1->AddEntry(TrackMomentumAllTime2_, "Momenta Rec 2"); legend1->Draw("same e"); c1->SaveAs("allTracksMomenta.png"); c1->Clear(); @@ -599,9 +690,9 @@ void TrackHitAnaProcessor::TrackMomenta(){ c1->SetTitle("Momentum for In Time Tracks"); TrackMomentumInTime1_->Draw("e"); TrackMomentumInTime2_->Draw("e same"); - auto legend2 = new TLegend(0.3,0.8,.68,.9); - legend2->AddEntry(TrackMomentumInTime1_,"Momenta Rec 1"); - legend2->AddEntry(TrackMomentumInTime2_,"Momenta Rec 2"); + auto legend2 = new TLegend(0.3, 0.8, .68, .9); + legend2->AddEntry(TrackMomentumInTime1_, "Momenta Rec 1"); + legend2->AddEntry(TrackMomentumInTime2_, "Momenta Rec 2"); legend2->Draw("same e"); c1->SaveAs("inTimeTracksMomenta.png"); c1->Clear(); @@ -610,9 +701,9 @@ void TrackHitAnaProcessor::TrackMomenta(){ c1->SetTitle("Momentum for Out Time Tracks"); TrackMomentumOutTime1_->Draw("e"); TrackMomentumOutTime2_->Draw("e same"); - auto legend3 = new TLegend(0.3,0.8,.68,.9); - legend3->AddEntry(TrackMomentumOutTime1_,"Momenta Rec 1"); - legend3->AddEntry(TrackMomentumOutTime2_,"Momenta Rec 2"); + auto legend3 = new TLegend(0.3, 0.8, .68, .9); + legend3->AddEntry(TrackMomentumOutTime1_, "Momenta Rec 1"); + legend3->AddEntry(TrackMomentumOutTime2_, "Momenta Rec 2"); legend3->Draw("same e"); c1->SaveAs("outTimeTracksMomenta.png"); c1->Clear(); @@ -637,13 +728,13 @@ void TrackHitAnaProcessor::TrackTransverseMomenta(){ TrackMomentumTInTime2_->SetLineColor(kBlue); TrackMomentumTOutTime2_->SetLineColor(kBlue); - c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->DrawFrame(0.0, 3000.0, 150.0, 7000.0); c1->SetTitle("Transverse Momentum for All Tracks"); TrackMomentumTAllTime1_->Draw("e"); TrackMomentumTAllTime2_->Draw("e same"); - auto legend1 = new TLegend(0.3,0.8,.68,.9); - legend1->AddEntry(TrackMomentumTAllTime1_,"Momenta Rec 1"); - legend1->AddEntry(TrackMomentumTAllTime2_,"Momenta Rec 2"); + auto legend1 = new TLegend(0.3, 0.8, .68, .9); + legend1->AddEntry(TrackMomentumTAllTime1_, "Momenta Rec 1"); + legend1->AddEntry(TrackMomentumTAllTime2_, "Momenta Rec 2"); legend1->Draw("same e"); c1->SaveAs("allTracksMomentaT.png"); c1->Clear(); @@ -651,9 +742,9 @@ void TrackHitAnaProcessor::TrackTransverseMomenta(){ c1->SetTitle("Transverse Momentum for In Time Tracks"); TrackMomentumTInTime1_->Draw("e"); TrackMomentumTInTime2_->Draw("e same"); - auto legend2 = new TLegend(0.3,0.8,.68,.9); - legend2->AddEntry(TrackMomentumTInTime1_,"Momenta Rec 1"); - legend2->AddEntry(TrackMomentumTInTime2_,"Momenta Rec 2"); + auto legend2 = new TLegend(0.3, 0.8, .68, .9); + legend2->AddEntry(TrackMomentumTInTime1_, "Momenta Rec 1"); + legend2->AddEntry(TrackMomentumTInTime2_, "Momenta Rec 2"); legend2->Draw("same e"); c1->SaveAs("inTimeTracksMomentaT.png"); c1->Clear(); @@ -661,9 +752,9 @@ void TrackHitAnaProcessor::TrackTransverseMomenta(){ c1->SetTitle("Transverse Momentum for Out Time Tracks"); TrackMomentumTOutTime1_->Draw("e"); TrackMomentumTOutTime2_->Draw("e same"); - auto legend3 = new TLegend(0.3,0.8,.68,.9); - legend3->AddEntry(TrackMomentumTOutTime1_,"Momenta Rec 1"); - legend3->AddEntry(TrackMomentumTOutTime2_,"Momenta Rec 2"); + auto legend3 = new TLegend(0.3, 0.8, .68, .9); + legend3->AddEntry(TrackMomentumTOutTime1_, "Momenta Rec 1"); + legend3->AddEntry(TrackMomentumTOutTime2_, "Momenta Rec 2"); legend3->Draw("same e"); c1->SaveAs("outTimeTracksMomentaT.png"); c1->Clear(); From 70c4510621e4570bdaef3c5b773ef52a6fbed8b7 Mon Sep 17 00:00:00 2001 From: Sarah Gaiser Date: Mon, 12 Feb 2024 18:42:01 -0800 Subject: [PATCH 58/70] small change --- processors/include/SvtRawDataAnaProcessor.h | 1 - 1 file changed, 1 deletion(-) diff --git a/processors/include/SvtRawDataAnaProcessor.h b/processors/include/SvtRawDataAnaProcessor.h index 112272702..47520175b 100644 --- a/processors/include/SvtRawDataAnaProcessor.h +++ b/processors/include/SvtRawDataAnaProcessor.h @@ -47,7 +47,6 @@ class SvtRawDataAnaProcessor : public Processor { * if do sample is on, it runs sampling. * **/ - virtual bool process(IEvent* ievent); /** From ceecdea24f8143d45ba63dcf26f2c395dbb20c4f Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Tue, 13 Feb 2024 13:06:13 -0800 Subject: [PATCH 59/70] Add files via upload --- processors/src/SVTClusterAnaProcessor.cxx | 2 +- .../src/TrackHitCompareAnaProcessor.cxx | 34 +++++++++---------- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/processors/src/SVTClusterAnaProcessor.cxx b/processors/src/SVTClusterAnaProcessor.cxx index a985636c6..1e6db1a96 100644 --- a/processors/src/SVTClusterAnaProcessor.cxx +++ b/processors/src/SVTClusterAnaProcessor.cxx @@ -23,7 +23,7 @@ void SVTClusterAnaProcessor::configure(const ParameterSet& parameters) { isMC_ = parameters.getInteger("isMC"); doingTracks_ = (parameters.getInteger("doTrack")==1); pcut_ = (float)parameters.getDouble("cut"); - badchann_ = parameters.getString("badchannels"); + badchann_ = parameters.getString("badchannels"); } catch (std::runtime_error& error) { diff --git a/processors/src/TrackHitCompareAnaProcessor.cxx b/processors/src/TrackHitCompareAnaProcessor.cxx index 611bfa151..8dafe0b50 100644 --- a/processors/src/TrackHitCompareAnaProcessor.cxx +++ b/processors/src/TrackHitCompareAnaProcessor.cxx @@ -8,12 +8,12 @@ #include "TrackHitCompareAnaProcessor.h" #include -TrackHitAnaProcessor::TrackHitAnaProcessor(const std::string& name, Process& process) : Processor(name, process){ +TrackHitCompareAnaProcessor::TrackHitCompareAnaProcessor(const std::string& name, Process& process) : Processor(name, process){ mmapper_ = new ModuleMapper(2021); } -TrackHitAnaProcessor::~TrackHitAnaProcessor(){} +TrackHitCompareAnaProcessor::~TrackHitCompareAnaProcessor(){} -void TrackHitAnaProcessor::configure(const ParameterSet& parameters) { +void TrackHitCompareAnaProcessor::configure(const ParameterSet& parameters) { std::cout << "Configuring TrackHitAnaProcessor" << std::endl; try { @@ -33,7 +33,7 @@ void TrackHitAnaProcessor::configure(const ParameterSet& parameters) { } -void TrackHitAnaProcessor::initialize(TTree* tree) { +void TrackHitCompareAnaProcessor::initialize(TTree* tree) { fillDeads(); tree_= tree; if (isMC_ == 1){ @@ -165,7 +165,7 @@ void TrackHitAnaProcessor::initialize(TTree* tree) { } } -bool TrackHitAnaProcessor::process(IEvent* ievent) { +bool TrackHitCompareAnaProcessor::process(IEvent* ievent) { if (doingTracks_){ for (int i = 0; isize(); i++){ Track* track = tracks_->at(i); @@ -406,7 +406,7 @@ bool TrackHitAnaProcessor::process(IEvent* ievent) { return true; } -void TrackHitAnaProcessor::fillDeads(){ +void TrackHitCompareAnaProcessor::fillDeads(){ for (int i = 0; i<24576; i++){ Deads_[i]=0.0; } @@ -422,7 +422,7 @@ void TrackHitAnaProcessor::fillDeads(){ return; } -int TrackHitAnaProcessor::GetStrip(int feb, int hyb, int strip){ +int TrackHitCompareAnaProcessor::GetStrip(int feb, int hyb, int strip){ int count = 0; if (feb <= 1){ count += feb*2048 + hyb*512 + strip; @@ -433,7 +433,7 @@ int TrackHitAnaProcessor::GetStrip(int feb, int hyb, int strip){ return count; } -void TrackHitAnaProcessor::PlotClusterLayers(){ +void TrackHitCompareAnaProcessor::PlotClusterLayers(){ TCanvas *c1 = new TCanvas("c"); gPad->SetLogy(true); c1->cd(); @@ -491,7 +491,7 @@ void TrackHitAnaProcessor::PlotClusterLayers(){ return; } -void TrackHitAnaProcessor::PlotClusterCharges(){ +void TrackHitCompareAnaProcessor::PlotClusterCharges(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); @@ -548,7 +548,7 @@ void TrackHitAnaProcessor::PlotClusterCharges(){ return; } -void TrackHitAnaProcessor::PlotClusterTimes(){ +void TrackHitCompareAnaProcessor::PlotClusterTimes(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); @@ -605,7 +605,7 @@ void TrackHitAnaProcessor::PlotClusterTimes(){ return; } -void TrackHitAnaProcessor::PlotClusterPositions(){ +void TrackHitCompareAnaProcessor::PlotClusterPositions(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); @@ -658,7 +658,7 @@ void TrackHitAnaProcessor::PlotClusterPositions(){ return; } -void TrackHitAnaProcessor::TrackMomenta(){ +void TrackHitCompareAnaProcessor::TrackMomenta(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); gPad->SetLogy(false); @@ -710,7 +710,7 @@ void TrackHitAnaProcessor::TrackMomenta(){ return; } -void TrackHitAnaProcessor::TrackTransverseMomenta(){ +void TrackHitCompareAnaProcessor::TrackTransverseMomenta(){ TCanvas *c1 = new TCanvas("c"); c1->cd(); gPad->SetLogy(false); @@ -761,15 +761,15 @@ void TrackHitAnaProcessor::TrackTransverseMomenta(){ return; } -void TrackHitAnaProcessor::finalize() { +void TrackHitCompareAnaProcessor::finalize() { PlotClusterLayers(); PlotClusterCharges(); PlotClusterTimes(); PlotClusterPositions(); if(doingTracks_){ - TrackMomenta()(); - TrackTransverseMomenta()(); + TrackMomenta(); + TrackTransverseMomenta(); } return; } -DECLARE_PROCESSOR(TrackHitAnaProcessor); +DECLARE_PROCESSOR(TrackHitCompareAnaProcessor); From 79b7bfef6e733f443bcdbbbd9146ef176d2e4270 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Tue, 13 Feb 2024 13:06:40 -0800 Subject: [PATCH 60/70] Add files via upload --- processors/include/SVTClusterAnaProcessor.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/processors/include/SVTClusterAnaProcessor.h b/processors/include/SVTClusterAnaProcessor.h index 834cceeb4..0d0ecda30 100644 --- a/processors/include/SVTClusterAnaProcessor.h +++ b/processors/include/SVTClusterAnaProcessor.h @@ -36,13 +36,13 @@ class TTree; -class SvtClusterAnaProcessor : public Processor { +class SVTClusterAnaProcessor : public Processor { public: - SvtClusterAnaProcessor(const std::string& name, Process& process); + SVTClusterAnaProcessor(const std::string& name, Process& process); - ~SvtClusterAnaProcessor(); + ~SVTClusterAnaProcessor(); /** * From 020ffb14e61e92bb1ecd6f421980ab75a51ebc47 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Tue, 13 Feb 2024 13:07:03 -0800 Subject: [PATCH 61/70] Add files via upload --- analysis/src/RawSvtHitHistos.cxx | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/analysis/src/RawSvtHitHistos.cxx b/analysis/src/RawSvtHitHistos.cxx index ef3d6f0bb..a8ea98af7 100644 --- a/analysis/src/RawSvtHitHistos.cxx +++ b/analysis/src/RawSvtHitHistos.cxx @@ -22,7 +22,7 @@ void RawSvtHitHistos::DefineHistos(){ //std::cout<<"hello2"< hybridStrings={}; std::string histokey; //std::cout<getAmp(i),weight); histokey = swTag + "_SvtHybrids_Chi_Sqr_h"; Fill1DHisto(histokey, rawSvtHit->getChiSq(i),weight); + + histokey = swTag + "_SvtHybrids_HitsPerCluster_h"; + Fill1DHisto(histokey,HITC,weight); + //Fill2DHisto(histokey,,,weight); + + histokey = swTag + "_SvtHybrids_HitsOnALayer_h"; + Fill1DHisto(histokey,HITL,weight); + //std::cout<getStrip()<getADCs(); @@ -82,8 +90,6 @@ void RawSvtHitHistos::FillHistograms(RawSvtHit* rawSvtHit,float weight,int i,uns // - - histokey = swTag + "_SvtHybrids_ADCcountdeshift_hh"; for(unsigned int K=1; K<6; K++){ if(feb<=1){ @@ -103,7 +109,19 @@ void RawSvtHitHistos::FillHistograms(RawSvtHit* rawSvtHit,float weight,int i,uns } //adcs_=rawSvtHit->getADCs(i); //Fill1DHisto(histokey, -(rawSvthit->getT0(i)),weight); + + histokey = swTag + "_SvtHybrids_T0Strip_hh"; + Fill2DHisto(histokey,rawSvtHit->getT0(i),rawSvtHit->getStrip()-STR,weight); + + histokey = swTag + "_SvtHybrids_2HitCluDiff_hh"; + Fill2DHisto(histokey,rawSvtHit->getT0(i),otherTime,weight); + + histokey = swTag + "_SvtHybrids_AmChi_Sqr_hh"; + Fill2DHisto(histokey, rawSvtHit->getChiSq(i), rawSvtHit->getAmp(i),weight); + histokey = swTag + "_SvtHybrids_T0Chi_Sqr_hh"; + Fill2DHisto(histokey, rawSvtHit->getChiSq(i), rawSvtHit->getT0(i),weight); + //std::cout<<"hello7"<getT0(i), rawSvtHit->getT0err(i),weight); From 836ec6afb24cf8e4ec2cdbaa41f04d8876345ac7 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Tue, 13 Feb 2024 13:07:24 -0800 Subject: [PATCH 62/70] Add files via upload --- analysis/include/RawSvtHitHistos.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/analysis/include/RawSvtHitHistos.h b/analysis/include/RawSvtHitHistos.h index c6a83082a..05025aef7 100644 --- a/analysis/include/RawSvtHitHistos.h +++ b/analysis/include/RawSvtHitHistos.h @@ -26,7 +26,7 @@ class RawSvtHitHistos : public HistoManager{ ~RawSvtHitHistos(); void DefineHistos(); - void FillHistograms(RawSvtHit* rawSvtHit,float weight = 1.,int Ireg=0,unsigned int nhit = 0,Float_t TimeDiff = -42069.0,Float_t AmpDiff = -42069.0); + void FillHistograms(RawSvtHit* rawSvtHit,float weight = 1.,int Ireg=0,unsigned int nhit = 0,Float_t TimeDiff = -42069.0,Float_t AmpDiff = -42069.0,int str=-10000, int hitc = 0, int hitl = 0,float otherTime = 69420.0); void saveHistosSVT(TFile* outF,std::string folder); private: From f687df76254f584e495d343f7507c307b7b1dc6c Mon Sep 17 00:00:00 2001 From: Sarah Gaiser Date: Tue, 13 Feb 2024 13:37:23 -0800 Subject: [PATCH 63/70] last formatting touches --- .vscode/settings.json | 5 + analysis/include/RawSvtHitHistos.h | 7 +- analysis/src/RawSvtHitHistos.cxx | 160 ++++++++++++----------------- scripts/AddIdentity.C | 20 ++-- 4 files changed, 86 insertions(+), 106 deletions(-) create mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 000000000..93f99837e --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,5 @@ +{ + "files.associations": { + "AddIdentity.C": "cpp" + } +} \ No newline at end of file diff --git a/analysis/include/RawSvtHitHistos.h b/analysis/include/RawSvtHitHistos.h index 05025aef7..632d8d33f 100644 --- a/analysis/include/RawSvtHitHistos.h +++ b/analysis/include/RawSvtHitHistos.h @@ -26,11 +26,12 @@ class RawSvtHitHistos : public HistoManager{ ~RawSvtHitHistos(); void DefineHistos(); - void FillHistograms(RawSvtHit* rawSvtHit,float weight = 1.,int Ireg=0,unsigned int nhit = 0,Float_t TimeDiff = -42069.0,Float_t AmpDiff = -42069.0,int str=-10000, int hitc = 0, int hitl = 0,float otherTime = 69420.0); - void saveHistosSVT(TFile* outF,std::string folder); + void FillHistograms(RawSvtHit* rawSvtHit, float weight = 1., int Ireg = 0, unsigned int nhit = 0, Float_t TimeDiff = -42069.0, Float_t AmpDiff = -42069.0, int strip = -10000, int hitc = 0, int hitl = 0, float otherTime = 69420.0); + void saveHistosSVT(TFile* outF, std::string folder); + private: - int Event_number=0; + int Event_number = 0; int debug_ = 1; int adcs_[6]; diff --git a/analysis/src/RawSvtHitHistos.cxx b/analysis/src/RawSvtHitHistos.cxx index a8ea98af7..85a2d7574 100644 --- a/analysis/src/RawSvtHitHistos.cxx +++ b/analysis/src/RawSvtHitHistos.cxx @@ -12,97 +12,84 @@ RawSvtHitHistos::~RawSvtHitHistos() { } void RawSvtHitHistos::DefineHistos(){ - //Define vector of hybrid names using ModuleMapper - //Use this list to define multiple copies of histograms, one for each hybrid, from json file + // Define vector of hybrid names using ModuleMapper + // Use this list to define multiple copies of histograms, one for each hybrid, from json file std::vector hybridNames; mmapper_->getStrings(hybridNames); std::string makeMultiplesTag = "SvtHybrids"; - //std::cout<<"hello1"< hybridStrings={}; +void RawSvtHitHistos::FillHistograms(RawSvtHit* rawSvtHit, float weight, int i, unsigned int i2, Float_t TimeDiff, Float_t AmpDiff, int strip, int hitc, int hitl, float otherTime) { + std::vector hybridStrings = {}; std::string histokey; //std::cout<=10000){return;} //if(Event_number==11) std::cout<getModule()); auto lay = std::to_string(rawSvtHit->getLayer()); - swTag= mmapper_->getStringFromSw("ly"+lay+"_m"+mod); - std::string helper = mmapper_->getHwFromSw("ly"+lay+"_m"+mod); + swTag = mmapper_->getStringFromSw("ly" + lay + "_m" + mod); + std::string helper = mmapper_->getHwFromSw("ly" + lay + "_m" + mod); char char_array[helper.length()+1]; - std::strcpy(char_array,helper.c_str()); + std::strcpy(char_array, helper.c_str()); int feb = (int)char_array[1]-48; int hyb = (int)char_array[3]-48; histokey = swTag + "_SvtHybrids_getFitN_h"; - //std::cout<<"hello3"<getFitN(),weight); + + Fill1DHisto(histokey, rawSvtHit->getFitN(), weight); histokey = swTag +"_SvtHybrids_T0_h"; - //std::cout<getT0(i)<getAmp(i)<getT0err(i)<getAmpErr(i)<getT0(i),weight); - //}//else{ - // Fill1DHisto(histokey, rawSvtHit->getT0(i)-27.0,weight); - //} - //std::cout<<"hello6"<getT0(i), weight); + histokey = swTag + "_SvtHybrids_Am_h"; - Fill1DHisto(histokey, rawSvtHit->getAmp(i),weight); + Fill1DHisto(histokey, rawSvtHit->getAmp(i), weight); histokey = swTag + "_SvtHybrids_Chi_Sqr_h"; - Fill1DHisto(histokey, rawSvtHit->getChiSq(i),weight); + Fill1DHisto(histokey, rawSvtHit->getChiSq(i), weight); histokey = swTag + "_SvtHybrids_HitsPerCluster_h"; - Fill1DHisto(histokey,HITC,weight); - //Fill2DHisto(histokey,,,weight); + Fill1DHisto(histokey, hitc, weight); histokey = swTag + "_SvtHybrids_HitsOnALayer_h"; - Fill1DHisto(histokey,HITL,weight); + Fill1DHisto(histokey, hitl, weight); - //std::cout<getStrip()<getADCs(); + int * adcs = rawSvtHit->getADCs(); int maxx = 0; - for(unsigned int K=0; K<6; K++){ - if(maxxgetT0(i)),((Float_t)(adcs[K]))/(rawSvtHit->getAmp(i)),weight); } - for(unsigned int K=1; K<6; K++){ - if(feb<=1){ - Fill2DHisto(histokey,24.0*K-(rawSvtHit->getT0(i)),((Float_t)(adcs[K])-Float_t(baseErr1_[feb][hyb][(int)(rawSvtHit->getStrip())][K]))/(rawSvtHit->getAmp(i)),weight); - }else{ - Fill2DHisto(histokey,24.0*K-(rawSvtHit->getT0(i)),((Float_t)(adcs[K])-Float_t(baseErr2_[feb-2][hyb][(int)(rawSvtHit->getStrip())][K]))/(rawSvtHit->getAmp(i)),weight); + for (unsigned int K=1; K<6; K++){ + if (feb <= 1){ + Fill2DHisto(histokey, 24.0*K-(rawSvtHit->getT0(i)), ((Float_t)(adcs[K])-Float_t(baseErr1_[feb][hyb][(int)(rawSvtHit->getStrip())][K]))/(rawSvtHit->getAmp(i)), weight); + } else { + Fill2DHisto(histokey, 24.0*K-(rawSvtHit->getT0(i)), ((Float_t)(adcs[K])-Float_t(baseErr2_[feb-2][hyb][(int)(rawSvtHit->getStrip())][K]))/(rawSvtHit->getAmp(i)), weight); } //((Float_t)maxx),weight); } - //NOW THE CODE FOR THE TGRAPH SHITE - // - - + // The following code is for the TGraph histokey = swTag + "_SvtHybrids_ADCcountdeshift_hh"; - for(unsigned int K=1; K<6; K++){ - if(feb<=1){ - if(std::abs(rawSvtHit->getT0(i)+60)<25){ - Fill2DHisto(histokey,K,((Float_t)(adcs[K])-Float_t(baseErr1_[feb][hyb][(int)(rawSvtHit->getStrip())][K])));//(rawSvtHit->getAmp(i)),weight); - }else{ - Fill2DHisto(histokey,K,((Float_t)(adcs[K])-Float_t(baseErr1_[feb][hyb][(int)(rawSvtHit->getStrip())][K])));//(rawSvtHit->getAmp(i)),weight); + for (unsigned int K=1; K<6; K++){ + if (feb <= 1){ + if (std::abs(rawSvtHit->getT0(i)+60) < 25){ + Fill2DHisto(histokey, K, ((Float_t)(adcs[K])-Float_t(baseErr1_[feb][hyb][(int)(rawSvtHit->getStrip())][K]))); //(rawSvtHit->getAmp(i)),weight); + } else { + Fill2DHisto(histokey, K, ((Float_t)(adcs[K])-Float_t(baseErr1_[feb][hyb][(int)(rawSvtHit->getStrip())][K]))); //(rawSvtHit->getAmp(i)),weight); } - }else{ - if(std::abs(rawSvtHit->getT0(i)+60)<25){ - Fill2DHisto(histokey,K,((Float_t)(adcs[K])-Float_t(baseErr2_[feb-2][hyb][(int)(rawSvtHit->getStrip())][K])));//(rawSvtHit->getAmp(i)),weight); - }else{ - Fill2DHisto(histokey,K,((Float_t)(adcs[K])-Float_t(baseErr2_[feb-2][hyb][(int)(rawSvtHit->getStrip())][K])));//(rawSvtHit->getAmp(i)),weight); + } else { + if (std::abs(rawSvtHit->getT0(i)+60) < 25){ + Fill2DHisto(histokey, K, ((Float_t)(adcs[K])-Float_t(baseErr2_[feb-2][hyb][(int)(rawSvtHit->getStrip())][K]))); //(rawSvtHit->getAmp(i)),weight); + } else { + Fill2DHisto(histokey, K, ((Float_t)(adcs[K])-Float_t(baseErr2_[feb-2][hyb][(int)(rawSvtHit->getStrip())][K]))); //(rawSvtHit->getAmp(i)),weight); } } //((Float_t)maxx),weight); @@ -111,72 +98,59 @@ void RawSvtHitHistos::FillHistograms(RawSvtHit* rawSvtHit,float weight,int i,uns //Fill1DHisto(histokey, -(rawSvthit->getT0(i)),weight); histokey = swTag + "_SvtHybrids_T0Strip_hh"; - Fill2DHisto(histokey,rawSvtHit->getT0(i),rawSvtHit->getStrip()-STR,weight); + Fill2DHisto(histokey, rawSvtHit->getT0(i), rawSvtHit->getStrip()-strip, weight); histokey = swTag + "_SvtHybrids_2HitCluDiff_hh"; - Fill2DHisto(histokey,rawSvtHit->getT0(i),otherTime,weight); + Fill2DHisto(histokey, rawSvtHit->getT0(i), otherTime, weight); histokey = swTag + "_SvtHybrids_AmChi_Sqr_hh"; - Fill2DHisto(histokey, rawSvtHit->getChiSq(i), rawSvtHit->getAmp(i),weight); + Fill2DHisto(histokey, rawSvtHit->getChiSq(i), rawSvtHit->getAmp(i), weight); histokey = swTag + "_SvtHybrids_T0Chi_Sqr_hh"; - Fill2DHisto(histokey, rawSvtHit->getChiSq(i), rawSvtHit->getT0(i),weight); + Fill2DHisto(histokey, rawSvtHit->getChiSq(i), rawSvtHit->getT0(i), weight); - //std::cout<<"hello7"<getT0(i), rawSvtHit->getT0err(i),weight); + Fill2DHisto(histokey, rawSvtHit->getT0(i), rawSvtHit->getT0err(i), weight); + histokey = swTag + "_SvtHybrids_AmErr_hh"; - //std::cout<<"hello8"<getAmp(i), rawSvtHit->getAmpErr(i),weight); + Fill2DHisto(histokey, rawSvtHit->getAmp(i), rawSvtHit->getAmpErr(i), weight); + histokey = swTag + "_SvtHybrids_AmT0_hh"; - //std::cout<<"hello9"<getT0(i), rawSvtHit->getAmp(i),weight); + Fill2DHisto(histokey, rawSvtHit->getT0(i), rawSvtHit->getAmp(i), weight); + histokey = swTag + "_SvtHybrids_AmErrT0Err_hh"; - //std::cout<<"hello10"<getT0err(i), rawSvtHit->getAmpErr(i),weight); + Fill2DHisto(histokey, rawSvtHit->getT0err(i), rawSvtHit->getAmpErr(i), weight); histokey = swTag + "_SvtHybrids_AmT0Err_hh"; - //std::cout<<"hello10"<getT0err(i), rawSvtHit->getAmp(i),weight); + Fill2DHisto(histokey, rawSvtHit->getT0err(i), rawSvtHit->getAmp(i), weight); histokey = swTag + "_SvtHybrids_AmErrT0_hh"; - //std::cout<<"hello10"<getT0(i), rawSvtHit->getAmpErr(i),weight); + Fill2DHisto(histokey, rawSvtHit->getT0(i), rawSvtHit->getAmpErr(i), weight); - if(i==1){ + if (i==1) { histokey = swTag + "_SvtHybrids_PT1PT2_hh"; - Fill2DHisto(histokey, rawSvtHit->getT0(1),rawSvtHit->getT0(0)); - }else{ + Fill2DHisto(histokey, rawSvtHit->getT0(1), rawSvtHit->getT0(0)); + } else { histokey = swTag + "_SvtHybrids_PT1PT2_hh"; - Fill2DHisto(histokey, rawSvtHit->getT0(0),rawSvtHit->getT0(1)); + Fill2DHisto(histokey, rawSvtHit->getT0(0), rawSvtHit->getT0(1)); } - if(TimeDiff==-42069){return;} - else{ + if (TimeDiff==-42069) { return; } + else { histokey = swTag + "_SvtHybrids_TD_h"; - Fill1DHisto(histokey, TimeDiff,weight); + Fill1DHisto(histokey, TimeDiff, weight); histokey = swTag + "_SvtHybrids_T0TD_hh"; - Fill2DHisto(histokey, rawSvtHit->getT0(i),TimeDiff,weight); + Fill2DHisto(histokey, rawSvtHit->getT0(i), TimeDiff, weight); histokey = swTag + "_SvtHybrids_AmErrTD_hh"; - Fill2DHisto(histokey, rawSvtHit->getAmpErr(i),TimeDiff,weight); + Fill2DHisto(histokey, rawSvtHit->getAmpErr(i), TimeDiff, weight); histokey = swTag + "_SvtHybrids_AmpTD_hh"; - Fill2DHisto(histokey, rawSvtHit->getAmp(i),TimeDiff,weight); + Fill2DHisto(histokey, rawSvtHit->getAmp(i), TimeDiff, weight); histokey = swTag + "_SvtHybrids_Amp12_hh"; - Fill2DHisto(histokey, rawSvtHit->getAmp(0),rawSvtHit->getAmp(1),weight); + Fill2DHisto(histokey, rawSvtHit->getAmp(0), rawSvtHit->getAmp(1), weight); histokey = swTag + "_SvtHybrids_ADTD_hh"; - Fill2DHisto(histokey, AmpDiff,TimeDiff,weight); + Fill2DHisto(histokey, AmpDiff, TimeDiff, weight); } - //} - //std::cout<<"hello11"<(regname, regionSelections_[i_reg]); - // } - //} + return; } diff --git a/scripts/AddIdentity.C b/scripts/AddIdentity.C index faae5b898..abee9f9ca 100644 --- a/scripts/AddIdentity.C +++ b/scripts/AddIdentity.C @@ -1,18 +1,18 @@ -/* -* SIMPLE ROOT MACRO. ASSOCIATES TO EACH EVENT IN A ROOT FILE AN IDENTIFIER WHICH -* CAN BE USED POST HADD TO PROCESS A SINGLE FILE WITH MULTIPLE RECONSTRUCTION ALGORITHMS -* USED IN A SINGLE PROCESSOR. -*/ +/** + * Simple ROOT macro + * Associates to each event in a ROOT file an identifier which can be used post hadd + * to process a single file with multiple reconstruction algorithms used in a single processor. + **/ void AddIdentity(){ - TFile *f = new TFile("rootcopy0.root","update"); + TFile *f = new TFile("rootcopy0.root", "update"); TTree *tree = (TTree *)(f->Get("HPS_Event")); Float_t helper = 1.0; - auto my_new_branch = tree->Branch("Identifier",&helper,"Identifier/F"); - for (Long64_t entry = 0 ; entry < tree->GetEntries() ; entry++ ) { + auto my_new_branch = tree->Branch("Identifier", &helper, "Identifier/F"); + for (Long64_t entry = 0; entry < tree->GetEntries(); entry++) { //tree->GetEntry(); /* something to compute my_local_variable */ - std::cout<Fill(); } - tree->Write("",TObject::kOverwrite); + tree->Write("", TObject::kOverwrite); } From b255f95b29bc91cac28956484a39f80e40d2842e Mon Sep 17 00:00:00 2001 From: sarahgaiser <69592687+sarahgaiser@users.noreply.github.com> Date: Tue, 13 Feb 2024 13:38:08 -0800 Subject: [PATCH 64/70] Delete .vscode/settings.json --- .vscode/settings.json | 5 ----- 1 file changed, 5 deletions(-) delete mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 93f99837e..000000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "files.associations": { - "AddIdentity.C": "cpp" - } -} \ No newline at end of file From 792ff00454817da0ee2f394c650ba77306186a4c Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Tue, 13 Feb 2024 14:05:25 -0800 Subject: [PATCH 65/70] Update trackHitCompareAna.py --- processors/config/trackHitCompareAna.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/processors/config/trackHitCompareAna.py b/processors/config/trackHitCompareAna.py index 04bbe6929..16ab5bb1b 100644 --- a/processors/config/trackHitCompareAna.py +++ b/processors/config/trackHitCompareAna.py @@ -37,7 +37,7 @@ ############################### # Processors # ############################### -cclua = HpstrConf.Processor('cclua', 'TCompareAnaProcessor') +cclua = HpstrConf.Processor('cclua', 'TrackHitCompareAnaProcessor') cclua.parameters["debug"] = 0 cclua.parameters["layer"] = options.layer cclua.parameters["module"] = options.module From 695f1a8dc64d3df29cbe33b2a5921caa742b3402 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Tue, 13 Feb 2024 14:08:25 -0800 Subject: [PATCH 66/70] Add files via upload --- analysis/data/badchannels2021.dat | 873 ++++++++++++++++++++++++++++++ 1 file changed, 873 insertions(+) create mode 100644 analysis/data/badchannels2021.dat diff --git a/analysis/data/badchannels2021.dat b/analysis/data/badchannels2021.dat new file mode 100644 index 000000000..aaf20c467 --- /dev/null +++ b/analysis/data/badchannels2021.dat @@ -0,0 +1,873 @@ +svt_channel_id +470 +802 +1145 +1320 +2371 +2448 +3443 +3444 +3966 +4737 +4739 +4745 +4747 +4749 +4751 +4753 +4755 +5364 +5374 +6624 +7819 +7966 +8001 +8574 +9203 +11776 +11777 +11778 +11779 +11780 +11781 +11782 +11783 +11784 +11785 +11786 +11787 +11788 +11789 +11790 +11791 +11792 +11793 +11794 +11795 +11796 +11797 +11798 +11799 +11800 +11801 +11802 +11803 +11804 +11805 +11806 +11807 +11808 +11809 +11810 +11811 +11812 +11813 +11814 +11815 +11816 +11817 +11818 +11819 +11820 +11821 +11822 +11823 +11824 +11825 +11826 +11827 +11828 +11829 +11830 +11831 +11832 +11833 +11834 +11835 +11836 +11837 +11838 +11839 +11840 +11841 +11842 +11843 +11844 +11845 +11846 +11847 +11848 +11849 +11850 +11851 +11852 +11853 +11854 +11855 +11856 +11857 +11858 +11859 +11860 +11861 +11862 +11863 +11864 +11865 +11866 +11867 +11868 +11869 +11870 +11871 +11872 +11873 +11874 +11875 +11876 +11877 +11878 +11879 +11880 +11881 +11882 +11883 +11884 +11885 +11886 +11887 +11888 +11889 +11890 +11891 +11892 +11893 +11894 +11895 +11896 +11897 +11898 +11899 +11900 +11901 +11902 +11903 +11904 +11905 +11906 +11907 +11908 +11909 +11910 +11911 +11912 +11913 +11914 +11915 +11916 +11917 +11918 +11919 +11920 +11921 +11922 +11923 +11924 +11925 +11926 +11927 +11928 +11929 +11930 +11931 +11932 +11933 +11934 +11935 +11936 +11937 +11938 +11939 +11940 +11941 +11942 +11943 +11944 +11945 +11946 +11947 +11948 +11949 +11950 +11951 +11952 +11953 +11954 +11955 +11956 +11957 +11958 +11959 +11960 +11961 +11962 +11963 +11964 +11965 +11966 +11967 +11968 +11969 +11970 +11971 +11972 +11973 +11974 +11975 +11976 +11977 +11978 +11979 +11980 +11981 +11982 +11983 +11984 +11985 +11986 +11987 +11988 +11989 +11990 +11991 +11992 +11993 +11994 +11995 +11996 +11997 +11998 +11999 +12000 +12001 +12002 +12003 +12004 +12005 +12006 +12007 +12008 +12009 +12010 +12011 +12012 +12013 +12014 +12015 +12016 +12017 +12018 +12019 +12020 +12021 +12022 +12023 +12024 +12025 +12026 +12027 +12028 +12029 +12030 +12031 +12032 +12033 +12034 +12035 +12036 +12037 +12038 +12039 +12040 +12041 +12042 +12043 +12044 +12045 +12046 +12047 +12048 +12049 +12050 +12051 +12052 +12053 +12054 +12055 +12056 +12057 +12058 +12059 +12060 +12061 +12062 +12063 +12064 +12065 +12066 +12067 +12068 +12069 +12070 +12071 +12072 +12073 +12074 +12075 +12076 +12077 +12078 +12079 +12080 +12081 +12082 +12083 +12084 +12085 +12086 +12087 +12088 +12089 +12090 +12091 +12092 +12093 +12094 +12095 +12096 +12097 +12098 +12099 +12100 +12101 +12102 +12103 +12104 +12105 +12106 +12107 +12108 +12109 +12110 +12111 +12112 +12113 +12114 +12115 +12116 +12117 +12118 +12119 +12120 +12121 +12122 +12123 +12124 +12125 +12126 +12127 +12128 +12129 +12130 +12131 +12132 +12133 +12134 +12135 +12136 +12137 +12138 +12139 +12140 +12141 +12142 +12143 +12144 +12145 +12146 +12147 +12148 +12149 +12150 +12151 +12152 +12153 +12154 +12155 +12156 +12157 +12158 +12159 +12160 +12161 +12162 +12163 +12164 +12165 +12166 +12167 +12168 +12169 +12170 +12171 +12172 +12173 +12174 +12175 +12176 +12177 +12178 +12179 +12180 +12181 +12182 +12183 +12184 +12185 +12186 +12187 +12188 +12189 +12190 +12191 +12192 +12193 +12194 +12195 +12196 +12197 +12198 +12199 +12200 +12201 +12202 +12203 +12204 +12205 +12206 +12207 +12208 +12209 +12210 +12211 +12212 +12213 +12214 +12215 +12216 +12217 +12218 +12219 +12220 +12221 +12222 +12223 +12224 +12225 +12226 +12227 +12228 +12229 +12230 +12231 +12232 +12233 +12234 +12235 +12236 +12237 +12238 +12239 +12240 +12241 +12242 +12243 +12244 +12245 +12246 +12247 +12248 +12249 +12250 +12251 +12252 +12253 +12254 +12255 +12256 +12257 +12258 +12259 +12260 +12261 +12262 +12263 +12264 +12265 +12266 +12267 +12268 +12269 +12270 +12271 +12272 +12273 +12274 +12275 +12276 +12277 +12278 +12279 +12280 +12281 +12282 +12283 +12284 +12285 +12286 +12287 +12288 +12289 +12290 +12291 +12292 +12293 +12294 +12295 +12296 +12297 +12298 +12299 +12300 +12301 +12302 +12303 +12304 +12305 +12306 +12307 +12308 +12309 +12310 +12311 +12312 +12313 +12314 +12315 +12316 +12317 +12318 +12319 +12320 +12321 +12322 +12323 +12324 +12325 +12326 +12327 +12328 +12329 +12330 +12331 +12332 +12333 +12334 +12335 +12336 +12337 +12338 +12339 +12340 +12341 +12342 +12343 +12344 +12345 +12346 +12347 +12348 +12349 +12350 +12351 +12352 +12353 +12354 +12355 +12356 +12357 +12358 +12359 +12360 +12361 +12362 +12363 +12364 +12365 +12366 +12367 +12368 +12369 +12370 +12371 +12372 +12373 +12374 +12375 +12376 +12377 +12378 +12379 +12380 +12381 +12382 +12383 +12384 +12385 +12386 +12387 +12388 +12389 +12390 +12391 +12392 +12393 +12394 +12395 +12396 +12397 +12398 +12399 +12400 +12401 +12402 +12403 +12404 +12405 +12406 +12407 +12408 +12409 +12410 +12411 +12412 +12413 +12414 +12415 +12461 +12526 +12630 +13311 +13889 +14143 +15290 +16063 +16127 +16767 +18868 +18869 +19968 +19969 +19970 +19971 +19972 +19973 +19974 +19975 +19976 +19977 +19978 +19979 +19980 +19981 +19982 +19983 +19984 +19985 +19986 +19987 +19988 +19989 +19990 +19991 +19992 +19993 +19994 +19995 +19996 +19997 +19998 +19999 +20000 +20001 +20002 +20003 +20004 +20005 +20006 +20007 +20008 +20009 +20010 +20011 +20012 +20013 +20014 +20015 +20016 +20017 +20018 +20019 +20020 +20021 +20022 +20023 +20024 +20025 +20026 +20027 +20028 +20029 +20030 +20031 +20032 +20033 +20034 +20035 +20036 +20037 +20038 +20039 +20040 +20041 +20042 +20043 +20044 +20045 +20046 +20047 +20048 +20049 +20050 +20051 +20052 +20053 +20054 +20055 +20056 +20057 +20058 +20059 +20060 +20061 +20062 +20063 +20064 +20065 +20066 +20067 +20068 +20069 +20070 +20071 +20072 +20073 +20074 +20075 +20076 +20077 +20078 +20079 +20080 +20081 +20082 +20083 +20084 +20085 +20086 +20087 +20088 +20089 +20090 +20091 +20092 +20093 +20094 +20095 +20863 +20991 +21117 +21119 +21121 +21183 +21247 +21311 +21313 +21315 +21439 +21501 +21503 +21567 +21631 +21697 +21759 +21761 +21821 +21823 +21887 +21889 +21949 +21951 +21953 +21977 +21978 +21979 +21980 +21981 +21982 +21983 +21984 +21985 +21986 +21987 +21988 +21989 +21990 +21991 +21992 +21993 +21994 +21995 +21996 +21997 +21998 +21999 +22000 +22001 +22002 +22003 +22004 +22005 +22006 +22007 +22008 +22009 +22010 +22011 +22012 +22013 +22014 +22015 +22271 +23872 +23874 From 7f30ee72d46f2ec3ecaf0b806fc1403bbf1b7830 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Tue, 13 Feb 2024 14:10:40 -0800 Subject: [PATCH 67/70] Add files via upload From 2d935270e4643f0752ad85dd8007a45bacca2ae9 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Tue, 13 Feb 2024 14:12:32 -0800 Subject: [PATCH 68/70] Delete processors/dat/badchannels2021.dat --- processors/dat/badchannels2021.dat | 873 ----------------------------- 1 file changed, 873 deletions(-) delete mode 100644 processors/dat/badchannels2021.dat diff --git a/processors/dat/badchannels2021.dat b/processors/dat/badchannels2021.dat deleted file mode 100644 index aaf20c467..000000000 --- a/processors/dat/badchannels2021.dat +++ /dev/null @@ -1,873 +0,0 @@ -svt_channel_id -470 -802 -1145 -1320 -2371 -2448 -3443 -3444 -3966 -4737 -4739 -4745 -4747 -4749 -4751 -4753 -4755 -5364 -5374 -6624 -7819 -7966 -8001 -8574 -9203 -11776 -11777 -11778 -11779 -11780 -11781 -11782 -11783 -11784 -11785 -11786 -11787 -11788 -11789 -11790 -11791 -11792 -11793 -11794 -11795 -11796 -11797 -11798 -11799 -11800 -11801 -11802 -11803 -11804 -11805 -11806 -11807 -11808 -11809 -11810 -11811 -11812 -11813 -11814 -11815 -11816 -11817 -11818 -11819 -11820 -11821 -11822 -11823 -11824 -11825 -11826 -11827 -11828 -11829 -11830 -11831 -11832 -11833 -11834 -11835 -11836 -11837 -11838 -11839 -11840 -11841 -11842 -11843 -11844 -11845 -11846 -11847 -11848 -11849 -11850 -11851 -11852 -11853 -11854 -11855 -11856 -11857 -11858 -11859 -11860 -11861 -11862 -11863 -11864 -11865 -11866 -11867 -11868 -11869 -11870 -11871 -11872 -11873 -11874 -11875 -11876 -11877 -11878 -11879 -11880 -11881 -11882 -11883 -11884 -11885 -11886 -11887 -11888 -11889 -11890 -11891 -11892 -11893 -11894 -11895 -11896 -11897 -11898 -11899 -11900 -11901 -11902 -11903 -11904 -11905 -11906 -11907 -11908 -11909 -11910 -11911 -11912 -11913 -11914 -11915 -11916 -11917 -11918 -11919 -11920 -11921 -11922 -11923 -11924 -11925 -11926 -11927 -11928 -11929 -11930 -11931 -11932 -11933 -11934 -11935 -11936 -11937 -11938 -11939 -11940 -11941 -11942 -11943 -11944 -11945 -11946 -11947 -11948 -11949 -11950 -11951 -11952 -11953 -11954 -11955 -11956 -11957 -11958 -11959 -11960 -11961 -11962 -11963 -11964 -11965 -11966 -11967 -11968 -11969 -11970 -11971 -11972 -11973 -11974 -11975 -11976 -11977 -11978 -11979 -11980 -11981 -11982 -11983 -11984 -11985 -11986 -11987 -11988 -11989 -11990 -11991 -11992 -11993 -11994 -11995 -11996 -11997 -11998 -11999 -12000 -12001 -12002 -12003 -12004 -12005 -12006 -12007 -12008 -12009 -12010 -12011 -12012 -12013 -12014 -12015 -12016 -12017 -12018 -12019 -12020 -12021 -12022 -12023 -12024 -12025 -12026 -12027 -12028 -12029 -12030 -12031 -12032 -12033 -12034 -12035 -12036 -12037 -12038 -12039 -12040 -12041 -12042 -12043 -12044 -12045 -12046 -12047 -12048 -12049 -12050 -12051 -12052 -12053 -12054 -12055 -12056 -12057 -12058 -12059 -12060 -12061 -12062 -12063 -12064 -12065 -12066 -12067 -12068 -12069 -12070 -12071 -12072 -12073 -12074 -12075 -12076 -12077 -12078 -12079 -12080 -12081 -12082 -12083 -12084 -12085 -12086 -12087 -12088 -12089 -12090 -12091 -12092 -12093 -12094 -12095 -12096 -12097 -12098 -12099 -12100 -12101 -12102 -12103 -12104 -12105 -12106 -12107 -12108 -12109 -12110 -12111 -12112 -12113 -12114 -12115 -12116 -12117 -12118 -12119 -12120 -12121 -12122 -12123 -12124 -12125 -12126 -12127 -12128 -12129 -12130 -12131 -12132 -12133 -12134 -12135 -12136 -12137 -12138 -12139 -12140 -12141 -12142 -12143 -12144 -12145 -12146 -12147 -12148 -12149 -12150 -12151 -12152 -12153 -12154 -12155 -12156 -12157 -12158 -12159 -12160 -12161 -12162 -12163 -12164 -12165 -12166 -12167 -12168 -12169 -12170 -12171 -12172 -12173 -12174 -12175 -12176 -12177 -12178 -12179 -12180 -12181 -12182 -12183 -12184 -12185 -12186 -12187 -12188 -12189 -12190 -12191 -12192 -12193 -12194 -12195 -12196 -12197 -12198 -12199 -12200 -12201 -12202 -12203 -12204 -12205 -12206 -12207 -12208 -12209 -12210 -12211 -12212 -12213 -12214 -12215 -12216 -12217 -12218 -12219 -12220 -12221 -12222 -12223 -12224 -12225 -12226 -12227 -12228 -12229 -12230 -12231 -12232 -12233 -12234 -12235 -12236 -12237 -12238 -12239 -12240 -12241 -12242 -12243 -12244 -12245 -12246 -12247 -12248 -12249 -12250 -12251 -12252 -12253 -12254 -12255 -12256 -12257 -12258 -12259 -12260 -12261 -12262 -12263 -12264 -12265 -12266 -12267 -12268 -12269 -12270 -12271 -12272 -12273 -12274 -12275 -12276 -12277 -12278 -12279 -12280 -12281 -12282 -12283 -12284 -12285 -12286 -12287 -12288 -12289 -12290 -12291 -12292 -12293 -12294 -12295 -12296 -12297 -12298 -12299 -12300 -12301 -12302 -12303 -12304 -12305 -12306 -12307 -12308 -12309 -12310 -12311 -12312 -12313 -12314 -12315 -12316 -12317 -12318 -12319 -12320 -12321 -12322 -12323 -12324 -12325 -12326 -12327 -12328 -12329 -12330 -12331 -12332 -12333 -12334 -12335 -12336 -12337 -12338 -12339 -12340 -12341 -12342 -12343 -12344 -12345 -12346 -12347 -12348 -12349 -12350 -12351 -12352 -12353 -12354 -12355 -12356 -12357 -12358 -12359 -12360 -12361 -12362 -12363 -12364 -12365 -12366 -12367 -12368 -12369 -12370 -12371 -12372 -12373 -12374 -12375 -12376 -12377 -12378 -12379 -12380 -12381 -12382 -12383 -12384 -12385 -12386 -12387 -12388 -12389 -12390 -12391 -12392 -12393 -12394 -12395 -12396 -12397 -12398 -12399 -12400 -12401 -12402 -12403 -12404 -12405 -12406 -12407 -12408 -12409 -12410 -12411 -12412 -12413 -12414 -12415 -12461 -12526 -12630 -13311 -13889 -14143 -15290 -16063 -16127 -16767 -18868 -18869 -19968 -19969 -19970 -19971 -19972 -19973 -19974 -19975 -19976 -19977 -19978 -19979 -19980 -19981 -19982 -19983 -19984 -19985 -19986 -19987 -19988 -19989 -19990 -19991 -19992 -19993 -19994 -19995 -19996 -19997 -19998 -19999 -20000 -20001 -20002 -20003 -20004 -20005 -20006 -20007 -20008 -20009 -20010 -20011 -20012 -20013 -20014 -20015 -20016 -20017 -20018 -20019 -20020 -20021 -20022 -20023 -20024 -20025 -20026 -20027 -20028 -20029 -20030 -20031 -20032 -20033 -20034 -20035 -20036 -20037 -20038 -20039 -20040 -20041 -20042 -20043 -20044 -20045 -20046 -20047 -20048 -20049 -20050 -20051 -20052 -20053 -20054 -20055 -20056 -20057 -20058 -20059 -20060 -20061 -20062 -20063 -20064 -20065 -20066 -20067 -20068 -20069 -20070 -20071 -20072 -20073 -20074 -20075 -20076 -20077 -20078 -20079 -20080 -20081 -20082 -20083 -20084 -20085 -20086 -20087 -20088 -20089 -20090 -20091 -20092 -20093 -20094 -20095 -20863 -20991 -21117 -21119 -21121 -21183 -21247 -21311 -21313 -21315 -21439 -21501 -21503 -21567 -21631 -21697 -21759 -21761 -21821 -21823 -21887 -21889 -21949 -21951 -21953 -21977 -21978 -21979 -21980 -21981 -21982 -21983 -21984 -21985 -21986 -21987 -21988 -21989 -21990 -21991 -21992 -21993 -21994 -21995 -21996 -21997 -21998 -21999 -22000 -22001 -22002 -22003 -22004 -22005 -22006 -22007 -22008 -22009 -22010 -22011 -22012 -22013 -22014 -22015 -22271 -23872 -23874 From 0b93b36d72967f110a625b2cdc08bb6c73fa6fc6 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Tue, 13 Feb 2024 14:13:40 -0800 Subject: [PATCH 69/70] Update trackHitCompareAna.py --- processors/config/trackHitCompareAna.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/processors/config/trackHitCompareAna.py b/processors/config/trackHitCompareAna.py index 16ab5bb1b..b9f4e058c 100644 --- a/processors/config/trackHitCompareAna.py +++ b/processors/config/trackHitCompareAna.py @@ -44,7 +44,7 @@ cclua.parameters["isMC"] = options.isMC cclua.parameters["doTrack"] = options.doTrack cclua.parameters["cut"] = options.cut -cclua.parameters["badchannels"] = os.environ['HPSTR_BASE']+"/processors/dat/badchannels2021.dat" +cclua.parameters["badchannels"] = os.environ['HPSTR_BASE']+"/analysis/data/badchannels2021.dat" sequence = [cclua] From 4ad1faa4bb04841826daadc3721e6858aa811831 Mon Sep 17 00:00:00 2001 From: rodwyer100 Date: Tue, 13 Feb 2024 14:14:21 -0800 Subject: [PATCH 70/70] Update trackHitClusterAna.py --- processors/config/trackHitClusterAna.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/processors/config/trackHitClusterAna.py b/processors/config/trackHitClusterAna.py index 9686eaf9a..40b50520d 100644 --- a/processors/config/trackHitClusterAna.py +++ b/processors/config/trackHitClusterAna.py @@ -44,7 +44,7 @@ clua.parameters["isMC"] = options.isMC clua.parameters["doTrack"] = options.doTrack clua.parameters["cut"] = options.cut -clua.parameters["badchannels"] = os.environ['HPSTR_BASE']+"/processors/dat/badchannels2021.dat" +clua.parameters["badchannels"] = os.environ['HPSTR_BASE']+"/analysis/data/badchannels2021.dat" sequence = [clua]