CorrelatedSpaceTree2.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_CorrelatedSpaceTree2
#include "CorrelatedSpaceTree2.h"
#endif

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

#ifndef ROOT_TBrowser
#include "TBrowser.h"
#endif

#ifndef ROOT_TFile
#include "TFile.h"
#endif

#ifndef ROOT_TH2
#include "TH2.h"
#endif

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

#ifndef ROOT_TTree
#include "TTree.h"
#endif


using namespace Gw;

//
ClassImp(CorrelatedSpaceTree2)

//__________________________________________________________
CorrelatedSpaceTree2::CorrelatedSpaceTree2(const char* name, const char* title) 
  : SymCorrelatedSpace(name, title),
        fTree(0x0),
        fBranchName("mat"),
    fLog("CorrelatedSpaceTree2")
{ 
  // default constructor

  SetDimension(2);
}

//__________________________________________________________
CorrelatedSpaceTree2::~CorrelatedSpaceTree2()
{
  // default destructor
  delete fTree;
}

//__________________________________________________________
const Char_t* CorrelatedSpaceTree2::GetTreeName() const
{
  return Form("%s_2D", GetName()); 
}

//__________________________________________________________
const Char_t* CorrelatedSpaceTree2::GetTreeTitle() const
{
  return Form("%s_2D", GetTitle()); 
}

//__________________________________________________________
void CorrelatedSpaceTree2::DeleteTree(Option_t* opt)
{
  fTree->Delete(opt); 
}

//__________________________________________________________
void CorrelatedSpaceTree2::AssertTree()
{
 
  if (fTree == 0x0) {
        fTree = new TTree(GetTreeName(), GetTreeTitle());
  }
}

//__________________________________________________________
void CorrelatedSpaceTree2::Fill(const Double_t* Xn, const Double_t weight)
{
  
  AssertTree();
  
  Int_t dimX = GetHisto("x")->GetNbinsX();
  SetNofCells(dimX*dimX);

  SetBranch();
  
  for (Int_t i = 0; i < dimX; ++i) {
        for (Int_t j = 0; j < dimX; ++j) {
          FillCounts(i, j, dimX, Xn, weight);
          fTree->Fill();
        }       
  }
}

//__________________________________________________________
void CorrelatedSpaceTree2::FillFromH2(TH2* h2)
{
  
  fLog.SetProcessMethod("FillFromH2(TH2* )");
  
  
  if (gFile == 0x0) {
        fLog << error << "No file exists to write" << dolog;
        return;
  }
  
  CheckH2InTree(h2);
  
  AssertTree();
  
  Int_t dimX = h2->GetNbinsX();
  SetNofCells(dimX*dimX);

  SetBins(dimX, 0, dimX, 0);
  
  SetBranch();
  
  for (Int_t i = 0; i < dimX; ++i) {
        printf("%d\r", i);
        for (Int_t j = 0; j < dimX; ++j) {
          FillCounts(i,j,h2);
          fTree->Fill();
        }       
  }

  fLog << dolog; 
}

//__________________________________________________________
void CorrelatedSpaceTree2::FillRandom(Int_t dim)
{
  fLog.SetProcessMethod("FillRandom(Int_t )");
  
  AssertTree();
  
  SetBins(dim, 0, dim, 0);
  SetNofCells(dim*dim);

  SetBranch();
  
  if (gFile == 0x0) {
        fLog << error << "No file exists to write" << dolog;
        return;
  }
  
  for (Int_t i = 0; i < dim; ++i) {
        printf("%d\r", i);
        for (Int_t j = 0; j < dim; ++j) {
          FillCounts(j);
          fTree->Fill();
        }       
  }
  
  fLog << dolog; 
}

//__________________________________________________________
void CorrelatedSpaceTree2::Browse(TBrowser* b) 
{ 
   fTree->Browse(b);
}

//__________________________________________________________
void CorrelatedSpaceTree2::Project(CSFilter* filter, Option_t* axis)
{  
  fLog.SetProcessMethod("Project(CSFilter*, Option_t* )");

  if (fStatus == kUndefined) {
        fLog << error << "Tree not defined" << dolog;
        return;
  }
  
  if (filter == 0x0) {
        fLog << error << "No filter definied yet" << dolog;
        return;
  }
  
  filter->SetCondition(1);
  filter->SetDimension(fDimension-1);
  
  Int_t idx = GetAxisNumber(axis);
  
  if (idx != 0) {
        fLog << warning << "Axis number out of range" << dolog;
        return;
  }
  

  TH1D* h1 = 0x0;
  if ( filter->IsForBkg() )
        h1 = static_cast<TH1D*> ( fHistoBkgList->At(idx) );
  else 
        h1 = static_cast<TH1D*> ( fHistoList->At(idx) );

  h1->Reset();
  Int_t dim = GetHistoTot("x")->GetNbinsX();
  
  SetBins(dim, 0, dim, idx);
  
  TBranch* b = SetAddress();
  
  Int_t    nofGates;
  Int_t    dimProj = fDimension - 1;
  Short_t  inGate[dimProj];
  Double_t energies[dimProj];
  
  for (Int_t i= 0; i < dim; ++i) {
        
        energies[0] = (Double_t)i;
        nofGates = filter->IsInside(energies, dimProj, inGate);
    
        if (nofGates > 1) {
          fLog << error << Form("Too much good energies : %d", nofGates) << dolog;
          return;
        }
        
        if (inGate[0] == 1) {
          for (Int_t j = 0; j < dim; ++j) { 
                b->GetEntry(i*dim + j);
                FillHisto(j, h1);
          }
        }
  }
  fLog << dolog; 
}

//_____________________________________________________________________________
void CorrelatedSpaceTree2::Project(Option_t* axis, Option_t* gateName) 
{ 
  CorrelatedSpace::Project(axis, gateName); 
}

//_____________________________________________________________________________
Int_t CorrelatedSpaceTree2::GetNbin(Int_t axis) const
{
  switch (axis) {
        case 0:
        case 1:
          return GetHistoTot("x")->GetNbinsX();
        default:
          return -1;
  }
}

//__________________________________________________________
void CorrelatedSpaceTree2::SetCellContent(Int_t iCell, Double_t weight)
{
  AssertTree();
  Int_t dim = GetHistoTot("x")->GetNbinsX();
  
  if (iCell >= dim*dim) {
        fLog.SetProcessMethod("GetCellContent(Int_t )");
        fLog <<  error << "index to large" << dolog;
        return;
  }
  
  static Bool_t first = false;
  
  if (first == false) {
        SetBranch();
        first = true;
  }
  
  SetCounts(weight);
  
  Int_t i = iCell / (dim);
  GetHistoTot("x")->Fill(i, weight);
  
  fTree->Fill();
}

//__________________________________________________________
Double_t CorrelatedSpaceTree2::GetContent(Int_t i, Int_t j)
{
  Int_t dim = GetHistoTot("x")->GetNbinsX();
  
  TBranch* b = SetAddress();
  
  b->GetEntry(i*dim + j);
  
  return GetCounts();
}

//__________________________________________________________
Double_t CorrelatedSpaceTree2::GetCellContent(Int_t i)
{  
  Int_t dim = GetHistoTot("x")->GetNbinsX();
  
  TBranch* b = SetAddress();
  
  if (i >= dim*dim) {
        fLog.SetProcessMethod("GetCellContent(Int_t )");
        fLog <<  error << "index to large" << dolog;
        return 0.;
  }
  
  b->GetEntry(i);
  return GetCounts();
}

//_____________________________________________________________________________
void CorrelatedSpaceTree2::Streamer(TBuffer &R__b)
{
  // Customized streamer 
  fLog.SetProcessMethod("Streamer(TBuffer& )");
  if (R__b.IsReading()) {
    CorrelatedSpaceTree2::Class()->ReadBuffer(R__b, this);
        fTree = (TTree*)gFile->Get(GetTreeName());
        if (fTree == 0x0) {
                fLog << error << "Cannot file tree in file" << nline;
          fStatus = kUndefined;
        }
        fStatus = kDefined;
  } else {
        fTree->Write("", kOverwrite);
    CorrelatedSpaceTree2::Class()->WriteBuffer(R__b, this);
  }
  fLog << dolog; 
}