StatisticalFluctuations.cxx

Go to the documentation of this file.

//
//
// Simple class to track variations on strip and module residuals
// and strip charges between subsets of data
//
// Package: DetectorAlignment
//
// Contact: rustem@fnal.gov
//
// Created on: Mon Jul 25 21:26:05 2005
//
#include <cassert>

#include "StatisticalFluctuations.h"
#include "NtpAlignmentRecord.h"
#include "MessageService/MsgService.h"
#include "MessageService/MsgFormat.h"

#include "TFile.h"
#include "TTree.h"

using namespace std;

CVSID("$Id: StatisticalFluctuations.cxx,v 1.5 2009/02/28 21:46:10 gmieg Exp $");

//____________________________________________________________________________________________
StatisticalFluctuations::StatisticalFluctuations(const VldContext &vldc)
   :fNumberOfSubsets(0)
{
   pair<unsigned int, VldContext> p_vld(fNumberOfSubsets, vldc);
   fmValidity.insert(p_vld);
}

//____________________________________________________________________________________________
void StatisticalFluctuations::Fill(const AlignmentStrip &astrip)
{
   PlexStripEndId plexseid(astrip.plexseid);      
   PlexScintMdlId plexmdlid = plexseid.GetScintMdlId();      
   
   //fill strip residual sample
   FillStripSubsetStat(fmStripResidualCurrentSubset, plexseid, astrip.residual);
   
   //fill strip charge sample
   FillStripSubsetStat(fmStripChargeCurrentSubset, plexseid, astrip.charge);
   
   //fill module residual sample
   FillModuleSubsetStat(fmMdlResidualCurrentSubset, plexmdlid, astrip.residual);
}

//____________________________________________________________________________________________
void StatisticalFluctuations::Reset(const VldContext &vldc, const int ntracks)
{
   fNumberOfSubsets++;

   //Get mean, sigm and size for current strip residual subset
   map<PlexStripEndId, SubsetSummary> StripResSummary;
   for(map<PlexStripEndId, SubsetStat>::const_iterator sit = fmStripResidualCurrentSubset.begin();
       sit != fmStripResidualCurrentSubset.end(); ++sit)
   {
      const SubsetStat stat = sit -> second;

      //create and fill stat summary struct  
      SubsetSummary summary;
      summary.mean  = stat.GetMean();
      summary.sigma = stat.GetSigma();
      summary.sum   = stat.GetSum();
      summary.size  = stat.GetSize();
      
      pair<PlexStripEndId, SubsetSummary> p(sit->first, summary);
      StripResSummary.insert(p);
   }

   map<unsigned int, map<PlexStripEndId, SubsetSummary> >::const_iterator fsit =
      fmStripResidualSample.find(fNumberOfSubsets);
   if(fsit != fmStripResidualSample.end())
      abort();
   else
   {
      pair<unsigned int, map<PlexStripEndId, SubsetSummary> > p(fNumberOfSubsets, StripResSummary);
      fmStripResidualSample.insert(p);
   }

   //Get mean, sigm and size for current strip charge subset
   map<PlexStripEndId, SubsetSummary> StripChargeSummary;
   for(map<PlexStripEndId, SubsetStat>::const_iterator sit = fmStripChargeCurrentSubset.begin();
       sit != fmStripChargeCurrentSubset.end(); ++sit)
   {
      const SubsetStat stat = sit -> second;

      //create and fill stat summary struct      
      SubsetSummary summary;
      summary.mean  = stat.GetMean();
      summary.sigma = stat.GetSigma();
      summary.sum   = stat.GetSum();
      summary.size  = stat.GetSize();
      
      pair<PlexStripEndId, SubsetSummary> p(sit->first, summary);
      StripChargeSummary.insert(p);
   }


   fsit = fmStripChargeSample.find(fNumberOfSubsets);
   if(fsit != fmStripChargeSample.end())
      abort();
   else
   {
      pair<unsigned int, map<PlexStripEndId, SubsetSummary> > p(fNumberOfSubsets, StripChargeSummary);
      fmStripChargeSample.insert(p);
   }

   //Get mean, sigm and size for current module residual subset
   map<PlexScintMdlId, SubsetSummary> MdlResSummary;
   for(map<PlexScintMdlId, SubsetStat>::const_iterator mit = fmMdlResidualCurrentSubset.begin();
       mit != fmMdlResidualCurrentSubset.end(); ++mit)
   {
      const SubsetStat stat = mit -> second;
      
      //create and fill stat summary struct  
      SubsetSummary summary;
      summary.mean  = stat.GetMean();
      summary.sigma = stat.GetSigma();
      summary.sum   = stat.GetSum();
      summary.size  = stat.GetSize();
      
      pair<PlexScintMdlId, SubsetSummary> p(mit->first, summary);
      MdlResSummary.insert(p);
   }

   map<unsigned int, map<PlexScintMdlId, SubsetSummary> >::const_iterator fmit =
      fmMdlResidualSample.find(fNumberOfSubsets);
   if(fmit != fmMdlResidualSample.end())
      abort();
   else
   {
      pair<unsigned int, map<PlexScintMdlId, SubsetSummary> > p(fNumberOfSubsets, MdlResSummary);
      fmMdlResidualSample.insert(p);
   }
   
   //insert validity context for time subset was reset
   pair<unsigned int, VldContext> p_vld(fNumberOfSubsets, vldc);
   fmValidity.insert(p_vld);

   
   pair<unsigned int, int> p_record(fNumberOfSubsets, ntracks);
   fmNRecords.insert(p_record);

   //clear subset maps
   fmStripResidualCurrentSubset.clear();
   fmStripChargeCurrentSubset.clear();
   fmMdlResidualCurrentSubset.clear();
}

//____________________________________________________________________________________________
void StatisticalFluctuations::FillStripSubsetStat(map<PlexStripEndId, SubsetStat> &set, 
                                             const PlexStripEndId &plexseid, 
                                             const double &value)
{
   map<PlexStripEndId, SubsetStat>::iterator fit = set.find(plexseid);
   
   //create and insert SubsetStat object if it does not exist
   //otherwise fill with strip residual
   if(fit == set.end())
   {
      SubsetStat stat;
      stat.Fill(value);
      pair<PlexStripEndId, SubsetStat> p(plexseid, stat);
      set.insert(p);
   }
   else
   {
      (fit -> second).Fill(value);
   }   
}

//____________________________________________________________________________________________
void StatisticalFluctuations::FillModuleSubsetStat(map<PlexScintMdlId, SubsetStat> &set, 
                                              const PlexScintMdlId &plexmdlid, 
                                              const double &value)
{
   map<PlexScintMdlId, SubsetStat>::iterator fit = set.find(plexmdlid);
   
   //create and insert SubsetStat object if it does not exist
   //otherwise fill with strip residual
   if(fit == set.end())
   {
      SubsetStat stat;
      stat.Fill(value);
      pair<PlexScintMdlId, SubsetStat> p(plexmdlid, stat);
      set.insert(p);
   }
   else
   {
      (fit -> second).Fill(value);
   }   
}

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

---