AlignmentRunSummary.cxx

Go to the documentation of this file.

//
//
// Simple class to track variations in reconstructed track quantities
//
// Package: DetectorAlignment
//
// Contact: rustem@fnal.gov
//
// Created on: Mon Jul 25 21:26:05 2005
//

//Local
#include "AlignmentRunSummary.h"
#include "NtpAlignmentRecord.h"

//MINOS
#include "MessageService/MsgService.h"
#include "MessageService/MsgFormat.h"

//ROOT
#include "TFile.h"
#include "TTree.h"

using namespace std;

CVSID("$Id: AlignmentRunSummary.cxx,v 1.2 2005/08/10 21:07:39 rustem Exp $");

//____________________________________________________________________________________________
AlignmentRunSummary::AlignmentRunSummary()
   :fNumberOfSubRuns(0),
    fCurrentRun(0),
    fCurrentSubRun(0)
{
}

//____________________________________________________________________________________________
void AlignmentRunSummary::Fill(const NtpAlignmentRecord *ntprec)
{
   if(!ntprec) return;

   const RecCandHeader candheader = ntprec -> GetHeader();      
   const int run    = candheader.GetRun();
   const int subrun = candheader.GetSubRun();

   if(fNumberOfSubRuns == 0 && fCurrentRun == 0 && fCurrentSubRun == 0)
   {
      fCurrentRun    = run;
      fCurrentSubRun = subrun;
   }

   if(fCurrentRun != run || fCurrentSubRun != subrun)
   {
      fNumberOfSubRuns++;  
      
      FillSummary(fNumberOfSubRuns, fVCandNStrip, fVCandNStripSummary);
      FillSummary(fNumberOfSubRuns, fUCandNStrip, fUCandNStripSummary);
      FillSummary(fNumberOfSubRuns, fVCandCharge, fVCandChargeSummary);
      FillSummary(fNumberOfSubRuns, fUCandCharge, fUCandChargeSummary);
      
      FillSummary(fNumberOfSubRuns, fVTrackNStrip, fVTrackNStripSummary);
      FillSummary(fNumberOfSubRuns, fUTrackNStrip, fUTrackNStripSummary);
      FillSummary(fNumberOfSubRuns, fVTrackCharge, fVTrackChargeSummary);
      FillSummary(fNumberOfSubRuns, fUTrackCharge, fUTrackChargeSummary);

      //const VldContext *vldc = ntprec -> GetHeader() -> GetVldContext());
      VldContext vldc(candheader.GetVldContext());
      
      pair<unsigned int, VldContext> p_vld(fNumberOfSubRuns, vldc);
      fmSubsetVldContext.insert(p_vld);
      
      pair<unsigned int, int> p_run(fNumberOfSubRuns, run);
      fmSubsetRunNumber.insert(p_run);
      
      pair<unsigned int, int> p_subrun(fNumberOfSubRuns, subrun);
      fmSubsetSubRunNumber.insert(p_subrun);
      
      fCurrentRun    = run;
      fCurrentSubRun = subrun;
   }
   
   fVCandNStrip.Fill(ntprec -> ncandvstrip);
   fUCandNStrip.Fill(ntprec -> ncandustrip);
   fVCandCharge.Fill(ntprec -> vcandcharge);
   fUCandCharge.Fill(ntprec -> ucandcharge);
   
   fVTrackNStrip.Fill(ntprec -> ntrackvstrip);
   fUTrackNStrip.Fill(ntprec -> ntrackustrip);
   fVTrackCharge.Fill(ntprec -> vcharge);
   fUTrackCharge.Fill(ntprec -> ucharge);
}

//____________________________________________________________________________________________
void AlignmentRunSummary::FillSummary(const unsigned int n, SubsetStat &stat, 
                                      map<unsigned int, SubsetSummary> &summary_map)
{
   SubsetSummary summary;
   summary.mean  = stat.GetMean();
   summary.sigma = stat.GetSigma();
   summary.size  = stat.GetSize();
   summary.sum   = stat.GetSum();

   pair<unsigned int, SubsetSummary> p(n, summary);
   summary_map.insert(p);
   stat.Reset();
}

//____________________________________________________________________________________________
TTree* AlignmentRunSummary::FillSummaryTree(TFile *rootfile)
{
   if(!rootfile)
   {
      MSG("Align", Msg::kError) << "Invalid root file pointer. Bailing out." << endl;
      return 0;
   }
   
   TTree *tree = new TTree("RunSummary","run summary");
   tree -> SetDirectory(rootfile);
   
   Int_t run, subrun;   
   Int_t second, date, time;
   UInt_t number_of_records, entry_number;

   Double_t mean_of_vtrack_nstrip,  mean_of_utrack_nstrip;
   Double_t mean_of_vtrack_charge,  mean_of_utrack_charge;
   Double_t sigma_of_vtrack_nstrip, sigma_of_utrack_nstrip;
   Double_t sigma_of_vtrack_charge, sigma_of_utrack_charge;
   Double_t sum_of_vtrack_nstrip,  sum_of_utrack_nstrip;
   Double_t sum_of_vtrack_charge,  sum_of_utrack_charge;

   Double_t mean_of_vcandnstrip,  mean_of_ucandnstrip;
   Double_t mean_of_vcandcharge,  mean_of_ucandcharge;
   Double_t sigma_of_vcandnstrip, sigma_of_ucandnstrip;
   Double_t sigma_of_vcandcharge, sigma_of_ucandcharge;
   Double_t sum_of_vcandnstrip,  sum_of_ucandnstrip;
   Double_t sum_of_vcandcharge,  sum_of_ucandcharge;
 
   tree -> Branch("run", &run, "run/I");
   tree -> Branch("subrun", &subrun, "subrun/I");
   tree -> Branch("second", &second, "second/I");
   tree -> Branch("date", &date, "date/I");
   tree -> Branch("time", &time, "time/I");
   tree -> Branch("entry_number", &entry_number, "entry_number/i");
   tree -> Branch("number_of_records", &number_of_records, "number_of_records/i");

   tree -> Branch("mean_of_vtrack_nstrip",  &mean_of_vtrack_nstrip,  "mean_of_vtrack_nstrip/D");
   tree -> Branch("mean_of_utrack_nstrip",  &mean_of_utrack_nstrip,  "mean_of_utrack_nstrip/D");
   tree -> Branch("mean_of_vtrack_charge",  &mean_of_vtrack_charge,  "mean_of_vtrack_charge/D");
   tree -> Branch("mean_of_utrack_charge",  &mean_of_utrack_charge,  "mean_of_utrack_charge/D");
   
   tree -> Branch("sum_of_vtrack_nstrip",  &sum_of_vtrack_nstrip,  "sum_of_vtrack_nstrip/D");
   tree -> Branch("sum_of_utrack_nstrip",  &sum_of_utrack_nstrip,  "sum_of_utrack_nstrip/D");
   tree -> Branch("sum_of_vtrack_charge",  &sum_of_vtrack_charge,  "sum_of_vtrack_charge/D");
   tree -> Branch("sum_of_utrack_charge",  &sum_of_utrack_charge,  "sum_of_utrack_charge/D");
  
   tree -> Branch("sigma_of_vtrack_nstrip", &sigma_of_vtrack_nstrip, "sigma_of_vtrack_nstrip/D");
   tree -> Branch("sigma_of_utrack_nstrip", &sigma_of_utrack_nstrip, "sigma_of_utrack_nstrip/D");
   tree -> Branch("sigma_of_vtrack_charge", &sigma_of_vtrack_charge, "sigma_of_vtrack_charge/D");
   tree -> Branch("sigma_of_utrack_charge", &sigma_of_utrack_charge, "sigma_of_utrack_charge/D");

   tree -> Branch("mean_of_vcandnstrip",  &mean_of_vcandnstrip,  "mean_of_vcandnstrip/D");
   tree -> Branch("mean_of_ucandnstrip",  &mean_of_ucandnstrip,  "mean_of_ucandnstrip/D");
   tree -> Branch("mean_of_vcandcharge",  &mean_of_vcandcharge,  "mean_of_vcandcharge/D");
   tree -> Branch("mean_of_ucandcharge",  &mean_of_ucandcharge,  "mean_of_ucandcharge/D");

   tree -> Branch("sum_of_vcandnstrip",  &sum_of_vcandnstrip,  "sum_of_vcandnstrip/D");
   tree -> Branch("sum_of_ucandnstrip",  &sum_of_ucandnstrip,  "sum_of_ucandnstrip/D");
   tree -> Branch("sum_of_vcandcharge",  &sum_of_vcandcharge,  "sum_of_vcandcharge/D");
   tree -> Branch("sum_of_ucandcharge",  &sum_of_ucandcharge,  "sum_of_ucandcharge/D");

   tree -> Branch("sigma_of_vcandnstrip", &sigma_of_vcandnstrip, "sigma_of_vcandnstrip/D");
   tree -> Branch("sigma_of_ucandnstrip", &sigma_of_ucandnstrip, "sigma_of_ucandnstrip/D");
   tree -> Branch("sigma_of_vcandcharge", &sigma_of_vcandcharge, "sigma_of_vcandcharge/D");
   tree -> Branch("sigma_of_ucandcharge", &sigma_of_ucandcharge, "sigma_of_ucandcharge/D");
   
   for(map<unsigned int, VldContext>::const_iterator vit = fmSubsetVldContext.begin();
       vit !=  fmSubsetVldContext.end(); ++vit)
   {
      entry_number = vit -> first;
      const VldContext vldc  = vit -> second;
      const VldTimeStamp vts = vldc.GetTimeStamp();
      second = vts.GetSec();
      date   = vts.GetDate();
      time   = vts.GetTime();
      

      map<unsigned int, int>:: const_iterator run_it = fmSubsetRunNumber.find(entry_number);
      if(run_it == fmSubsetRunNumber.end())
      {
         MSG("Align", Msg::kError) << "Failed to find map item." << endl;
         run = -1;
      }else
         run = run_it -> second;
      
      run_it = fmSubsetSubRunNumber.find(entry_number);
      if(run_it == fmSubsetSubRunNumber.end())
      {
         MSG("Align", Msg::kError) << "Failed to find map item." << endl;
         subrun = -1;
      }else
         subrun = run_it -> second;

      number_of_records = GetSubsetSize(entry_number, fVTrackNStripSummary);
      
      //strips on track
      mean_of_vtrack_nstrip = GetSubsetMean(entry_number, fVTrackNStripSummary);
      mean_of_utrack_nstrip = GetSubsetMean(entry_number, fUTrackNStripSummary);

      mean_of_vtrack_charge = GetSubsetMean(entry_number, fVTrackChargeSummary);
      mean_of_utrack_charge = GetSubsetMean(entry_number, fUTrackChargeSummary);

      sum_of_vtrack_nstrip = GetSubsetSum(entry_number, fVTrackNStripSummary);
      sum_of_utrack_nstrip = GetSubsetSum(entry_number, fUTrackNStripSummary);

      sum_of_vtrack_charge = GetSubsetSum(entry_number, fVTrackChargeSummary);
      sum_of_utrack_charge = GetSubsetSum(entry_number, fUTrackChargeSummary);

      sigma_of_vtrack_nstrip = GetSubsetSigma(entry_number, fVTrackNStripSummary);
      sigma_of_utrack_nstrip = GetSubsetSigma(entry_number, fUTrackNStripSummary);

      sigma_of_vtrack_charge = GetSubsetSigma(entry_number, fVTrackChargeSummary); 
      sigma_of_utrack_charge = GetSubsetSigma(entry_number, fUTrackChargeSummary);
      
      //strips not on track
      mean_of_vcandnstrip = GetSubsetMean(entry_number, fVCandNStripSummary);
      mean_of_ucandnstrip = GetSubsetMean(entry_number, fUCandNStripSummary);

      mean_of_vcandcharge = GetSubsetMean(entry_number, fVCandChargeSummary);
      mean_of_ucandcharge = GetSubsetMean(entry_number, fUCandChargeSummary);

      sum_of_vcandnstrip = GetSubsetSum(entry_number, fVCandNStripSummary);
      sum_of_ucandnstrip = GetSubsetSum(entry_number, fUCandNStripSummary);

      sum_of_vcandcharge = GetSubsetSum(entry_number, fVCandChargeSummary);
      sum_of_ucandcharge = GetSubsetSum(entry_number, fUCandChargeSummary);

      sigma_of_vcandnstrip = GetSubsetSigma(entry_number, fVCandNStripSummary);
      sigma_of_ucandnstrip = GetSubsetSigma(entry_number, fUCandNStripSummary);

      sigma_of_vcandcharge = GetSubsetSigma(entry_number, fVCandChargeSummary);
      sigma_of_ucandcharge = GetSubsetSigma(entry_number, fUCandChargeSummary);

      tree -> Fill();
   }
   
   return tree;
}

//____________________________________________________________________________________________
double AlignmentRunSummary::GetSubsetMean(const unsigned int nsubset, 
                                          const map<unsigned int, SubsetSummary> &summary) const
{
   map<unsigned int, SubsetSummary>::const_iterator fit = summary.find(nsubset);
   if(fit == summary.end())
   {
      MSG("Align", Msg::kError) << "Failed to find map item." << endl;
      return -1.0;
   }
   
   const SubsetSummary &s = fit -> second;
   return s.mean;
}

//____________________________________________________________________________________________
double AlignmentRunSummary::GetSubsetSigma(const unsigned int nsubset, 
                                           const map<unsigned int, SubsetSummary> &summary) const
{
   map<unsigned int, SubsetSummary>::const_iterator fit = summary.find(nsubset);
   if(fit == summary.end())
   {
      MSG("Align", Msg::kError) << "Failed to find map item." << endl;
      return -1.0;
   }
   
   const SubsetSummary &s = fit -> second;
   return s.sigma;
}

//____________________________________________________________________________________________
unsigned int AlignmentRunSummary::GetSubsetSize(const unsigned int nsubset, 
                                                const map<unsigned int, SubsetSummary> &summary) const
{
   map<unsigned int, SubsetSummary>::const_iterator fit = summary.find(nsubset);
   if(fit == summary.end())
   {
      MSG("Align", Msg::kError) << "Failed to find map item." << endl;
      return 0;
   }
   
   const SubsetSummary &s = fit -> second;
   return s.size;
}  

//____________________________________________________________________________________________
double AlignmentRunSummary::GetSubsetSum(const unsigned int nsubset, 
                                         const map<unsigned int, SubsetSummary> &summary) const
{
   map<unsigned int, SubsetSummary>::const_iterator fit = summary.find(nsubset);
   if(fit == summary.end())
   {
      MSG("Align", Msg::kError) << "Failed to find map item." << endl;
      return 0;
   }
   
   const SubsetSummary &s = fit -> second;
   return s.sum;
}  

//____________________________________________________________________________________________
AlignmentRunSummary::~AlignmentRunSummary()
{
}

---