CorrelatedSpaceLightTree3.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_CorrelatedSpaceLightTree3
#include "CorrelatedSpaceLightTree3.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_TH3
#include "TH3.h"
#endif

#ifndef ROOT_TRandom
#include "TRandom.h"
#endif

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

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


using namespace Gw;

//
ClassImp(CorrelatedSpaceLightTree3)

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

  SetDimension(3);
}

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

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

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

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

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

//__________________________________________________________
void CorrelatedSpaceLightTree3::SetBranch()
{
   fTree->Branch(fBranchName.Data(), fX, "fX[3]/s");
}

//__________________________________________________________
TBranch* CorrelatedSpaceLightTree3::SetAddress()
{
   fLog.SetProcessMethod("SetAddress()");
   
   TBranch* b = fTree->GetBranch(fBranchName.Data());
   if (b == 0x0) {
          fLog << warning << "Branch not find in tree" << dolog;
          return 0x0;
   }
   
   b->SetAddress(&fX);
   
   return b;
}

//__________________________________________________________
void CorrelatedSpaceLightTree3::Fill(const Double_t* Xn, const Double_t /*weight*/)
{
  
   static Bool_t first = false;
   
   if (first == false) {
          AssertTree();
          SetBranch();
          Int_t dimX = GetHisto("x")->GetNbinsX();
          SetBins(dimX, 0, dimX, 0);
          first = true;
   }
   
   fX[0] = Short_t(Xn[0]+0.5);
   fX[1] = Short_t(Xn[1]+0.5);
   fX[2] = Short_t(Xn[2]+0.5);
 
   fTree->Fill();
   GetHistoTot("x")->Fill(fX[0]);
 }

//__________________________________________________________
void CorrelatedSpaceLightTree3::FillFromH3(TH3* h3)
{
  
  fLog.SetProcessMethod("FillFromH2(TH2* )");
  
  
  if (gFile == 0x0) {
        fLog << error << "No file exists to write" << dolog;
        return;
  }
  
  //CheckH2InTree(h2);
  
  AssertTree();
  
   Double_t count = 0;
   Int_t nCells = 0;
   Int_t dimX = h3->GetNbinsX();
   SetBins(dimX, 0, dimX, 0);

   SetBranch();
   
   for (Int_t i = 0; i < dimX; ++i) {
          fX[0] = i;
          for (Int_t j = 0; j < dimX; ++j) {
                 fX[1] = j;
                 for (Int_t k = 0; k < dimX; ++k) {
                        fX[2] = k;
                        count = h3->GetBinContent(h3->GetBin(i,j,k));
                        for (Int_t l = 0; l < count; ++l) {
                           nCells++;
                           fTree->Fill();
                        }
                 }
          }     
   }
   TH1D* h =   GetHistoTot("x");
   fTree->Project(h->GetName(),"fX[0]", "");
   SetNofCells(nCells);
   
  fLog << dolog; 
}

//__________________________________________________________
void CorrelatedSpaceLightTree3::FillRandom(TH1* h1, Int_t nEvents)
{
   fLog.SetProcessMethod("FillRandom(TH1*, Int_t )");
   
   AssertTree();
   
   if (gFile == 0x0) {
          fLog << error << "No file exists to write" << dolog;
          return;
   }
   
   SetNofCells(nEvents);
   
   Int_t dimX = h1->GetNbinsX();
   
   SetBins(dimX, 0, dimX, 0);
   
   SetBranch();
   for (Int_t i = 0; i < nEvents; ++i) {
          
          fX[0] = (Short_t)h1->GetRandom();
          fX[1] = (Short_t)h1->GetRandom();
          fX[2] = (Short_t)h1->GetRandom();   
          fTree->Fill();
   }
   
   TH1D* h = GetHistoTot("x");
   fTree->Project(h->GetName(),"fX[0]", "fX[0]>0", "", nEvents, 0);
   fLog << dolog; 
}

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

//__________________________________________________________
void CorrelatedSpaceLightTree3::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;
   }
   
   Int_t idx = GetAxisNumber(axis);
   
   if (idx != 0) {
          fLog << warning << "Axis number out of range, set to zero cos symetrical CS" << dolog;
          idx = 0;
   }
   
   if (filter->IsCombined()) {
          if (!filter->IsListFilled(0) && !filter->IsListFilled(1)) {
                 fLog << error << "Gate list must be filled on axis x and y" << dolog;
                 return;
          }       
          ProjectCombined(filter, idx);
   } else {
          ProjectSimple(filter, idx);
   }
}

//__________________________________________________________
void CorrelatedSpaceLightTree3::ProjectSimple(CSFilter* filter, Int_t idx)
{   
   filter->SetCondition(2);
   filter->SetDimension(fDimension-1);
   
   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;
   Short_t  inGate[dimProj];
   Double_t energies[dimProj];
   
   Int_t nEntries = fTree->GetEntries();
   for (Int_t i= 0; i < nEntries; ++i) {
          b->GetEntry(i);
          
          energies[0] = fX[0];
          energies[1] = fX[1];
          energies[2] = fX[2];
          nofGates = filter->IsInside(energies, dimProj, inGate);
          
          for (Int_t k= 0; k < fDimension; ++k) {
                 if (nofGates == 2) {
                        if (inGate[k] == 0) {
                           h1->Fill(fX[k]); 
                        }
                 }
                 if (nofGates == 3) {
                        h1->Fill(fX[k]); 
                 }
                 
          }
   }
   fLog << dolog; 
}


//__________________________________________________________
void CorrelatedSpaceLightTree3::ProjectCombined(CSFilter* filter, Int_t idx)
{    
   filter->SetCondition(1);
   filter->SetDimension(fDimension-1);
   
   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  inGate1[dimProj];
   Short_t  inGate2[dimProj];
   Double_t energies[dimProj+1];
   
   Int_t nEntries = fTree->GetEntries();
   for (Int_t i= 0; i < nEntries; ++i) {
          b->GetEntry(i);
          
          for (Int_t j = 0; j < fDimension; ++j) {
                 if (j == 0) {
                        energies[0] = fX[1];
                        energies[1] = fX[2];
                        energies[2] = fX[0];
                 } else if (j == 1) {
                        energies[0] = fX[0];
                        energies[1] = fX[1];
                        energies[2] = fX[2];
                 } else {
                        energies[0] = fX[0];
                        energies[1] = fX[2];
                        energies[2] = fX[1];
                 }
                 
//         nofGates = filter->IsInside(energies, dimProj, inGate1, 0);
//         nofGates = filter->IsInside(energies, dimProj, inGate2, 1);
                 
         filter->IsInside(energies, dimProj, inGate1, 0);
         filter->IsInside(energies, dimProj, inGate2, 1);

                 if(inGate1[0]*inGate2[0] == 1)
                        h1->Fill(energies[2]); 
          }
   }
   fLog << dolog; 
}

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

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

//__________________________________________________________
void CorrelatedSpaceLightTree3::SetCellContent(Int_t /*iCell*/, Double_t /*weight*/)
{
   fLog.SetProcessMethod("GetCellContent(Int_t, Double_t)");
   fLog <<  warning << "Method not yet available" << dolog;

}

//__________________________________________________________
Double_t CorrelatedSpaceLightTree3::GetCellContent(Int_t /*i*/)
{  
   fLog.SetProcessMethod("GetCellContent(Int_t )");
   fLog <<  warning << "Method not yet available" << dolog;
   return 0.;
}

//_____________________________________________________________________________
void CorrelatedSpaceLightTree3::Streamer(TBuffer &R__b)
{
  // Customized streamer 
  fLog.SetProcessMethod("Streamer(TBuffer& )");
  if (R__b.IsReading()) {
    CorrelatedSpaceLightTree3::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);
    CorrelatedSpaceLightTree3::Class()->WriteBuffer(R__b, this);
  }
  fLog << dolog; 
}