CSManager.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2006 by Olivier Stezowski & Christian Finck        *
 *   stezow(AT)ipnl.in2p3.fr, cfinck(AT)ires.in2p3.fr                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef Gw_CSManager
#include "CSManager.h"
#endif

#ifndef Gw_CubicFilter
#include "CubicFilter.h"
#endif

#ifndef Gw_CorrelatedSpace
#include "CorrelatedSpace.h"
#endif

#ifndef Gw_Peak1D
#include "Peak1D.h"
#endif

#ifndef Gw_PeakCreator
#include "PeakCreator.h"
#endif

#ifndef ROOT_TCanvas
#include "TCanvas.h"
#endif

#ifndef ROOT_TFolder
#include "TFolder.h"
#endif

#ifndef ROOT_TH1D
#include "TH1D.h"
#endif

#ifndef ROOT_TList
#include "TList.h"
#endif

#ifndef ROOT_TROOT
#include "TROOT.h"
#endif

#include "TStyle.h"


using namespace Gw;

//
ClassImp(CSManager)

const TString CSManager::fgkFolderName        = "CSManager";
const TString CSManager::fgkFilterFolderName  = "Filter";
        Int_t CSManager::fgNofInstance        = 0;

//__________________________________________________________
CSManager::CSManager() 
  : TNamed("CSManager", "Default"),
        fRegCS(new TList()),
        fFilterBaseName("Gate"),
        fIsCanvasDiv(false),
    fLog("CSManager")
{ 
  // default constructor
  fRegCS->SetOwner(false);
  
  SetFolders();
}

//__________________________________________________________
CSManager::CSManager(const char* name, const char* title) 
: TNamed(name, title),
  fRegCS(new TList()),
  fFilterBaseName("Gate"),
  fIsCanvasDiv(false),
  fLog("CSManager")
{ 
  // default constructor
  fRegCS->SetOwner(false);
  
  SetFolders();
 }

//__________________________________________________________
void CSManager::SetFolders()
{
  fgNofInstance++;
  fCInstance = fgNofInstance;
  
  TString nameFolder = GetFolderName();
  TFolder* folder =  (TFolder*)gROOT->FindObjectAny(nameFolder.Data());
  if (folder == 0x0) {
        folder = gROOT->GetRootFolder()->AddFolder(fgkFolderName.Data(),"Folder");
  }
  
  if ((CorrelatedSpace*)gROOT->FindObjectAny(Form("%s/%s", nameFolder.Data(), GetName())) ) {
        SetName(Form("%s%d", GetName(), fCInstance-1));
  }
  folder->Add(this);
  
  nameFolder = GetFilterFolderName();
  
  TFolder* folderFilter =  (TFolder*)gROOT->FindObjectAny(nameFolder.Data());
  if (folderFilter == 0x0) {
        folder->AddFolder(Form("%s_%s",GetName(), fgkFilterFolderName.Data()),"Folder");
  }
  folderFilter =  (TFolder*)gROOT->FindObjectAny(nameFolder.Data());
  folderFilter->SetOwner(true);
}

//__________________________________________________________
Float_t CSManager::GetRatio(CSFilter* filter)
{
   Float_t bkg  = 0;
   Float_t gate = 0;
   for (Int_t i = 0; i < filter->GetNofPeaks(); ++i) {
          Peak1D* peak = (Peak1D*)filter->GetPeak(i);
          peak->Area("g");
          bkg  += peak->GetBkgIntegral();
          gate += peak->GetSubPeakIntegral();
   }
   return gate/bkg;
}

//__________________________________________________________
CSManager::~CSManager()
{
  // default destructor
  delete fRegCS;
  TFolder *folder = (TFolder*)gROOT->FindObjectAny(GetFilterFolderName().Data());
  folder->Delete();
}

//__________________________________________________________
TString CSManager::GetFolderName()
{
  TString nameFolder = fgkFolderName;
  nameFolder.Prepend("/");
  
  return nameFolder;
}

//__________________________________________________________
TString CSManager::GetFilterFolderName()
{
  TString nameFolder = fgkFolderName;
  nameFolder.Prepend("/");
  nameFolder.Append("/");
  nameFolder.Append(Form("%s_%s",GetName(), fgkFilterFolderName.Data()));
  return nameFolder;
}

//__________________________________________________________
TCanvas* CSManager::GetCanvas()
{
  TSeqCollection* listCanvas = gROOT->GetListOfCanvases();
  
  TString name(GetName());
  TCanvas* canvas = 0x0;
  TIter next(listCanvas);
  
  while ( (canvas = (TCanvas*)next()) ) {
        if ( !name.CompareTo(canvas->GetName()) ) {
          break; 
        }
  }
  
  if (canvas == 0x0) {
        canvas = new TCanvas(GetName(), GetTitle());
        PeakCreator::AddPeakCreator();
  }
  canvas->SetLeftMargin(0.12);
  canvas->SetRightMargin(0.05);
  canvas->Draw();
  
  if (!fIsCanvasDiv) {
        Int_t entries = fRegCS->GetEntries()*2;
         canvas->Divide(1,entries);
        fIsCanvasDiv = true;
  }
  
  return canvas;
}

//__________________________________________________________
TVirtualPad* CSManager::GetProjTotPad(Int_t idx)
{
   TCanvas* canvas = GetCanvas();
   return canvas->cd(2*idx+1);
}

//__________________________________________________________
TVirtualPad* CSManager::GetProjPad(Int_t idx)
{
   TCanvas* canvas = GetCanvas();
   return canvas->cd(2*idx+2);
}

//__________________________________________________________
void CSManager::DrawProj(Option_t* opt)
{
  CubicFilter* filter = 0x0;
  Int_t entries = fRegCS->GetEntries();
        
  for (Int_t i = 0; i < entries; ++i) {
         
        filter = (CubicFilter*)GetFilter(Form("%s%d",GetFilterBaseName(), i));
        if (filter == 0x0) {
                fLog.SetProcessMethod("DrawProj(Option_t* )");
                fLog << error << "filter not defined" << dolog;
                continue;
        }
         
        GetProjTotPad(i);
        Float_t ratio = GetRatio(filter);
         
        GetProjPad(i);
        
        TH1D* proj = GetHisto(i);
         
    proj->SetYTitle("Number of Counts");
        proj->SetXTitle("Energy"); 
        proj->SetTitleOffset(1.2,"X");
        proj->SetTitleOffset(1.5,"Y"); 
        proj->SetLabelOffset(0.01);
         
        TH1D* projBkg = GetHistoBkg(i);
        proj->Add(projBkg, -ratio);
         
        proj->Draw(opt);

        filter->Draw("gate");
  }
  GetCanvas()->Update();
}

//__________________________________________________________
void CSManager::DrawProjTot(Option_t* opt,  Option_t* axis)
{  
  Int_t entries = fRegCS->GetEntries();

  for (Int_t i = 0; i < entries; ++i) {
         GetProjTotPad(i);

        TH1D* proj = GetHistoTot(axis, i);
        proj->SetYTitle("Number of Counts");
        proj->SetXTitle("Energy"); 
        proj->SetTitleOffset(1.2,"X");
        proj->SetTitleOffset(1.5,"Y"); 
        proj->SetLabelOffset(0.01);
         
        proj->Draw(opt);
  }
  GetCanvas()->Update();
}

//__________________________________________________________
Int_t CSManager::CollectGate(Option_t* opt)
{
  fLog.SetProcessMethod("CollecGate(Option_t* )");
  
  // add filter
  CubicFilter* filter = 0x0;
  
  TString option(opt);  
  option.ToLower();

  // find last drawn histo 
//  TVirtualPad* pad = 0x0;
  
  TObject* obj = 0x0;
  Int_t nPeak = 0;
  TCanvas* hC = GetCanvas();
  
  Int_t entries = fRegCS->GetEntries();

  for (Int_t i = 0; i < entries; ++i) {
        
        filter = (CubicFilter*)GetFilter(Form("%s%d",GetFilterBaseName(), i));
        if (option.Contains("reset")) {
          filter->Reset();
        }
        
        TVirtualPad* cpad = 0x0;
          cpad = hC->GetPad(2*i+1);
        
        TIter next(cpad->GetListOfPrimitives());
        while ( (obj = next()) )  {
          if ( obj->InheritsFrom("TH1") ) 
//              pad = cpad;
          if ( obj->InheritsFrom("Gw::BasePeak") ) { // clear previous peak
                Peak1D* peak = dynamic_cast<Peak1D*> (obj);
                if (peak) {
                  if ( Peak1D::IsvalideGateColor(peak->GetLineColorPeak()) ) {
                        filter->AddPeak(peak);
                        nPeak++;
                  }
                }
          }
        }
  }
  fLog << dolog;
  
  return nPeak;
}

//__________________________________________________________
void CSManager::Register(CorrelatedSpace* cs)
{
  CorrelatedSpace* regCS = dynamic_cast<CorrelatedSpace*> ( CorrelatedSpace::GetCSList()->FindObject(cs) );
  
  if (regCS == 0x0) {
        fLog.SetProcessMethod("Register(CorrelatedSpace* )");
        fLog << error << "CS not registred !" << dolog;
        return;
  }
  
  fRegCS->Add(cs);
  EnableCanvasDiv();
}

//__________________________________________________________
TH1D* CSManager::GetHistoTot(Option_t* axis, Int_t iCS) const
{
  if (iCS >= fRegCS->GetEntries()) {
        fLog.SetProcessMethod("GetHistoTot(Option_t* )");
        fLog << error << "CS index too large" << dolog;
        return 0x0;
  }
  
  CorrelatedSpace* cs = (CorrelatedSpace*)fRegCS->At(iCS);
  TH1D* proj = cs->GetHistoTot(axis);
  
  return proj;
}

//__________________________________________________________
TH1D* CSManager::GetHisto(Int_t iCS) const
{
  if (iCS >= fRegCS->GetEntries()) {
        fLog.SetProcessMethod("GetHisto(Option_t* )");
        fLog << error << "CS index too large" << dolog;
        return 0x0;
  }
  
  CorrelatedSpace* cs = (CorrelatedSpace*)fRegCS->At(iCS);
  TH1D* proj = cs->GetHisto();
  
  return proj;
}

//__________________________________________________________
TH1D* CSManager::GetHistoBkg(Int_t iCS) const
{
  if (iCS >= fRegCS->GetEntries()) {
        fLog.SetProcessMethod("GetHistoBkg(Option_t* )");
        fLog << error << "CS index too large" << dolog;
        return 0x0;
  }
  
  CorrelatedSpace* cs = (CorrelatedSpace*)fRegCS->At(iCS);
  TH1D* proj = cs->GetHistoBkg();
  
  return proj;
}

//__________________________________________________________
CSFilter* CSManager::GetFilter(Option_t* gateName)
{
  // add filter
  TString nameFolder = GetFilterFolderName();

  TFolder *folder = (TFolder*)gROOT->FindObjectAny(nameFolder.Data());
  if (folder == 0x0) {
        fLog.SetProcessMethod("GetFilter(Option_t* )");
        fLog << error << "No folder found for filter" << dolog;
        return 0x0;
  }
  
  TString name = nameFolder;
  name.Append("/");
  name.Append(gateName);
  
  CubicFilter* filter = (CubicFilter*)gROOT->FindObjectAny(name.Data());
  
  if ( filter == 0x0 ) {
        filter = new CubicFilter();
        filter->SetName(gateName);
        folder->Add(filter);
  }
  return filter;
}

//__________________________________________________________
void CSManager::Project(Option_t* axis)
{
  if (fRegCS->GetEntries() <= 0) {
        fLog.SetProcessMethod("Project(Option_t*, Option_t* )");
        fLog << error << "No correlated space registered" << dolog;
        return;
  }
  
  CubicFilter* filter = 0x0;
  CorrelatedSpace* cs = 0x0;
  
  for (Int_t i = 0; i < fRegCS->GetEntries(); ++i) {
        cs = dynamic_cast<CorrelatedSpace*> ( fRegCS->At(i) );
        filter = (CubicFilter*)GetFilter(Form("%s%d",GetFilterBaseName(), i));
        filter->MakeGates();
        cs->Project(filter, axis);
        
        filter->MakeGates("bkg");
        cs->Project(filter, axis);
  }
}

//__________________________________________________________
void CSManager::Convert(CorrelatedSpace* src, CorrelatedSpace* dst)
{
  if (dst) 
        dst->Import(src);  
}