CorrelatedSpace.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_CorrelatedSpace
#include "CorrelatedSpace.h"
#endif

#ifndef Gw_CSFilter
#include "CSFilter.h"
#endif

#ifndef Gw_CSManager
#include "CSManager.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

#ifndef ROOT_TString
#include "TString.h"
#endif

using namespace Gw;

//
ClassImp(CorrelatedSpace)

const Char_t* CorrelatedSpace::fgkDefaultName = "Correlated_Space";
const TString CorrelatedSpace::fgkFolderName  = "CS";
       TList* CorrelatedSpace::fgCorrSpaces   = 0x0; 

//__________________________________________________________
CorrelatedSpace::CorrelatedSpace() 
  : TNamed(),
    fDimension(0), // has to be set
        fHistoTotList(0x0),
        fHistoList(0x0),
        fHistoBkgList(0x0),
        fStatus(kUndefined),
    fLog("CorrelatedSpace")
{ 
  // default constructor
}

//__________________________________________________________
CorrelatedSpace::CorrelatedSpace(const char* name, const char* title) 
: TNamed(name, title),
  fDimension(0), // has to be set
  fHistoTotList(new TList()),
  fHistoList(new TList()),
  fHistoBkgList(new TList()),
  fStatus(kUndefined),
  fLog("CorrelatedSpace")
{ 
  // default constructor
  fHistoList->SetOwner(true);
  fHistoBkgList->SetOwner(true);
  fHistoTotList->SetOwner(true);
  
  if (fgCorrSpaces == 0x0) {
        fgCorrSpaces = new TList();
        fgCorrSpaces->SetOwner(false);
  }
  
  TString nameFolder = fgkFolderName;
  nameFolder.Prepend("/");
  TFolder* folder =  (TFolder*)gROOT->FindObjectAny(nameFolder.Data());
  if (folder == 0x0) {
        folder = gROOT->GetRootFolder()->AddFolder(fgkFolderName,"Folder");
        for (Int_t i = 0; i < GetCSList()->GetEntries(); ++i) {
          folder->Add(GetCSList()->At(i));
        }
  }
  folder->Add(this);
  fgCorrSpaces->Add(this);
}

//__________________________________________________________
CorrelatedSpace::~CorrelatedSpace()
{
  // default destructor
  delete fHistoTotList;
  delete fHistoList;
  
  //remove for list and folder
  GetCSList()->Remove(this);
  TString nameFolder = fgkFolderName;
  nameFolder.Prepend("/");
  TFolder* folder =  (TFolder*)gROOT->FindObjectAny(nameFolder.Data());
  folder->Remove(this);
}

//__________________________________________________________
TH1D* CorrelatedSpace::GetHisto(Option_t* axis)
{
  Int_t idx = GetAxisNumber(axis);
  if (idx < 0 || idx > fDimension) {
        fLog.SetProcessMethod("GetHisto(Option_t* )");
        fLog << warning << "Axis number out of range" << dolog;
        return 0x0;
  }
  
  TH1D* h1 = static_cast<TH1D*> ( fHistoList->At(idx) );
  
  return h1;
}

//__________________________________________________________
TH1D* CorrelatedSpace::GetHistoBkg(Option_t* axis)
{
  Int_t idx = GetAxisNumber(axis);
  if (idx < 0 || idx > fDimension) {
        fLog.SetProcessMethod("GetHistoBkg(Option_t* )");
        fLog << warning << "Axis number out of range" << dolog;
        return 0x0;
  }
  
  TH1D* h1 = static_cast<TH1D*> ( fHistoBkgList->At(idx) );
  
  return h1;
}

//__________________________________________________________
TH1D* CorrelatedSpace::GetHistoTot(Option_t* axis)
{
  
  Int_t idx = GetAxisNumber(axis);
  if (idx < 0 || idx > fDimension) {
        fLog.SetProcessMethod("GetHistoTot(Option_t* )");
        fLog << warning << "Axis number out of range" << dolog;
        return 0x0;
  }
  
  TH1D* h1 = static_cast<TH1D*> ( fHistoTotList->At(idx) );
  
  return h1;
}

//__________________________________________________________
TH1D* CorrelatedSpace::GetHistoTot(Option_t* axis) const
{
  
  Int_t idx = GetAxisNumber(axis);
  if (idx < 0 || idx > fDimension) {
        fLog.SetProcessMethod("GetHistoTot(Option_t* )");
        fLog << warning << "Axis number out of range" << dolog;
        return 0x0;
  }
    
  TH1D* h1 = static_cast<TH1D*> ( fHistoTotList->At(idx) );
  
  return h1;
}

//__________________________________________________________
void CorrelatedSpace::SetBins(Int_t bin, Double_t min, Double_t max, Int_t axis)
{
  if (axis < 0 || axis > fDimension) {
        fLog.SetProcessMethod("SetBins(Int_t, Double_t, Double_t, Int_t )");
        fLog << warning << "Axis number out of range" << dolog;
        return;
  }
  
  TH1D* h1 = static_cast<TH1D*> ( fHistoList->At(axis) );
  
  if (h1)
        h1->SetBins(bin, min, max);
  
  TH1D* h1t = static_cast<TH1D*> ( fHistoTotList->At(axis) );
  
  if (h1t)
        h1t->SetBins(bin, min, max);
  
  TH1D* h1b = static_cast<TH1D*> ( fHistoBkgList->At(axis) );
  
  if (h1b)
        h1b->SetBins(bin, min, max);
  
  fStatus = kDefined;
  
}

//__________________________________________________________
void CorrelatedSpace::Project(Option_t* axis, Option_t* gateName)
{  
  fLog.SetProcessMethod("Project(Option_t*, Option_t* )");
  
  TString name(CSFilter::GetFolderName());
  name.Prepend("/");
  name.Append("/");
  name.Append(gateName);
  
  CSFilter* filter = (CSFilter*)gROOT->FindObjectAny(name.Data());
  
  if (filter == 0x0) {
        fLog << error << Form("No filter %s defined", name.Data()) << dolog;
        return;
  }
  
  Project(filter, axis);
  
  fLog << dolog; 
}

//__________________________________________________________
void CorrelatedSpace::Import(CorrelatedSpace* cs)
{
  // set dimension & # cells
  fDimension = cs->GetDimension();
  SetNofCells(cs->GetNofCells());
  
  // set bins
  for (Int_t j = 0; j < fDimension; ++j) {
        SetBins(cs->GetNbin(j), 0, cs->GetNbin(j), j);
  }
  
  // set cells
  for (Int_t i = 0; i < GetNofCells(); ++i) {
        SetCellContent(i, cs->GetCellContent(i));
  }
}