BaseSpectrumPlayer.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.             *
 ***************************************************************************/

#include <Riostream.h>


#ifndef ROOT_KeySymbols
#include "KeySymbols.h"
#endif

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

#ifndef ROOT_TClass
#include "TClass.h"
#endif

#ifndef ROOT_TContextMenu
#include "TContextMenu.h"
#endif

#ifndef ROOT_TH1
#include "TH1.h"
#endif

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

#ifndef ROOT_TFormula
#include "TFormula.h"
#endif

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

#ifndef ROOT_TMath
#include "TMath.h"
#endif

#ifndef ROOT_TPad
#include "TPad.h"
#endif

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

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

#ifndef Gw_BaseSpectrumPlayer
#include "BaseSpectrumPlayer.h"
#endif


using namespace Gw;

//

//__________________________________________________________
BaseSpectrumPlayer::BaseSpectrumPlayer() 
  : TNamed("SpectrumPlayer","Player for spectra"),
    fCreator(0x0),
    fPeakList(0x0),
    fInnerPeakList(0x0),
    fLastX(0),
    fLastY(0),
    fIsHelpsPrintActive(true),
    fContextMenu(0x0),
    fLog("BaseSpectrumPlayer")
{ 
    fCreator = new PeakCreator();

    // default constructor
    fInnerPeakList   = new TList(); fInnerPeakList->SetOwner(true);
    fPeakList        = fInnerPeakList;
}

//__________________________________________________________
BaseSpectrumPlayer::~BaseSpectrumPlayer()
{
    // default destructor
    fPeakList = 0x0;

    if (fCreator)
        { delete fCreator; fCreator = 0x0; }

    fInnerPeakList->Delete();
    if (fInnerPeakList)
        { delete fInnerPeakList; fInnerPeakList = 0x0; }

    Disconnect();
}


//__________________________________________________________
Bool_t BaseSpectrumPlayer::IsInRange(TH1* h, BasePeak* peak)
{
   if ( h->GetDimension() != 1) {
      fLog.SetProcessMethod("IsInRange(TH1* , BasePeak* )");
      fLog << error << "2D peak method not implemented yet" << dolog;
      return false;
   }

   Int_t firstBin = h->GetXaxis()->GetFirst();
   Int_t lastBin  = h->GetXaxis()->GetLast();

   Float_t low  = h->GetBinCenter(firstBin);
   Float_t high = h->GetBinCenter(lastBin);

   if (peak->GetPosition() - 2*peak->GetFWHM() > low && peak->GetPosition() + 2*peak->GetFWHM() < high)
      return true;
   else {
      fLog.SetProcessMethod("IsInRange(TH1* , BasePeak* )");
      fLog << info << Form("Peak %s not fitted cos out of zoom", peak->GetName()) << dolog;
      return false;
   }

   return false;
}

//__________________________________________________________
Bool_t BaseSpectrumPlayer::Connect(TCanvas *canvas)
{
    TCanvas *localCanvas = canvas;

    // in this case connect the current canvas
    if ( canvas == 0x0 ) {
        if ( TVirtualPad::Pad() )
          localCanvas = TVirtualPad::Pad()->GetCanvas();
        else {
          fLog.SetProcessMethod("Connect(TCanvas* )");
          fLog << error << "gPad not existing" << dolog;
        }
    }
    if ( localCanvas) {

        // to fit graphically
        localCanvas->Connect("ProcessedEvent(Int_t, Int_t, Int_t, TObject*)",
                         "Gw::BaseSpectrumPlayer",
                         this,
                         "HandleMovement(Int_t, Int_t, Int_t, TObject*)");

        fContextMenu = localCanvas->GetContextMenu();

        // add a peak creator to the canvas if it does not exists

        if ( ! PeakCreator::IsPeakCreator(localCanvas) ) {
            // change the characteristics ?
            // PeakCreator *p = PeakCreator::AddPeakCreator(localCanvas);
           fCreator->AddCreatorToList();
           fCreator->Connect();
        }
        else
        {
           fCreator->Connect();
        }
        fCreator->Collect();
    }
    return localCanvas != 0x0;
}

 //__________________________________________________________
Bool_t BaseSpectrumPlayer::Disconnect(TCanvas *canvas)
{
    fLog.SetProcessMethod("Disconnect(TCanvas* )");


    TCanvas *localCanvas = canvas;

    // in this case connect the current canvas
    if ( canvas == 0x0 ) {
        if ( TVirtualPad::Pad() )
          localCanvas = TVirtualPad::Pad()->GetCanvas();
        else {
          fLog << error << "gPad not existing" << dolog;
        }
    }
    if ( localCanvas ) {
       if (localCanvas->Disconnect("ProcessedEvent(Int_t, Int_t, Int_t, TObject*)",
                               this,
                               "HandleMovement(Int_t, Int_t, Int_t, TObject*)"))
          fLog << info << "Disconnected from Canvas" << dolog;
       else
          fLog << error << "Cannot disconnected from Canvas" << dolog;

    }
    fContextMenu = 0x0;

    PeakCreator *PC = PeakCreator::IsPeakCreator(localCanvas);
    if(PC) PC->Disconnect();

    fLog << dolog;
    return localCanvas != 0x0;
} 

//__________________________________________________________
void BaseSpectrumPlayer::HandleMovement(Int_t eventType, Int_t eventX, Int_t eventY, TObject* /*select*/)
{ 
//      // handle cursor mouvement
//      TVirtualPad *pad = gROOT->GetSelectedPad(), *cpad = TVirtualPad::Pad();

//      if ( pad != cpad )
//      pad->cd();

    if( eventType == kKeyPress) {

        Int_t keysym = eventY;

        if((EKeySym)eventY == kKey_a && (EKeySym)eventX == kKey_a && (EKeySym)fLastY == kKey_f && (EKeySym)fLastX == kKey_f)
            PopupFitMenu();

        if((EKeySym)eventY == kKey_m && (EKeySym)eventX == kKey_m && (((EKeySym)fLastY == kKey_s && (EKeySym)fLastX == kKey_s) || ((EKeySym)fLastY == kKey_h && (EKeySym)fLastX == kKey_h)))
        {
            if(TVirtualPad::Pad() == 0x0) return;
            TList *list = TVirtualPad::Pad()->GetListOfPrimitives();
            if(list==0x0) return;

            for(int i=0 ; i<list->GetSize() ; i++)
            {
                TObject *o = list->At(i);
                if(o->InheritsFrom("Gw::Peak1D"))
                {
                    Peak1D *peak = (Peak1D*)o;
                    if(peak->IsDrawAs(Peak1D::kGate)) continue;
                    else
                    {
                        if((EKeySym)fLastY == kKey_s) peak->SetDrawOption("ml");
                        else peak->SetDrawOption("!m!l");
                    }
                }
            }

            gPad->Modified();
            gPad->Update();
        }

        if ( (EKeySym)keysym == kKey_h && fIsHelpsPrintActive) {
            fLog << info;
            fLog << "\tf + a: pop up fit panel menu" << nline;
            fLog << dolog;
        }
    }

    fLastX = eventX; fLastY = eventY;

//      cpad->cd();
}

//__________________________________________________________
void BaseSpectrumPlayer::PopupFitMenu()
{
   TMethod* m = Class()->GetMethod("FitAll", "");

   if (m != 0x0 && fContextMenu != 0x0)
      fContextMenu->Action(this, m);
   else {
      fLog.SetProcessMethod("PopupFitMenu()");
      fLog << error << "Cannot Popup FitAll dialog box" << dolog;
   }
}


//__________________________________________________________
void BaseSpectrumPlayer::FitAll(const char* nameFunc, Option_t* optFit, Option_t* optBkg)
{
   // fit all peak in list with a common function and background
   if ( CollectPeaks() == 0 )
      return;

   BasePeak* peak  = 0x0;
   BasePeak* peak2 = 0x0;

   TString FuncName = nameFunc;
//   FuncName.ToLower();
   TString BackOpt = optBkg;
//   BackOpt.ToLower();

   if(FuncName == "DTGaus" && BackOpt.Contains("Step"))
   {
       FuncName = "DTGaus_Step";
       BackOpt = "";
   }

   TList peaks; peaks.SetOwner(false);

   // sort peak in list
   SortPeakList();

   TString opt(optFit);
   // rename if name of peaks are the same
   if ( RenamePeak(GetName()) ) {
      fLog.SetProcessMethod("FitAll(const char*, Option_t*, Option_t* )");
      fLog << warning << "Rename peaks cos they have the same name" << dolog;
   }

   TH1 *h = PadManager::GetHisto();

   if(h == 0x0)
       return;

   if ( h->GetDimension() >= 2) {
      fLog.SetProcessMethod("FitAll(const char*, Option_t*, Option_t* )");
      fLog << error << "2D peak fitting not implemented yet" << dolog;
      return;
   }

   Bool_t IsUsed[GetPeakList()->GetEntries()];
   for (Int_t i = 0; i < GetPeakList()->GetEntries(); ++i)
      IsUsed[i] = false;

   for (Int_t i = 0; i < GetPeakList()->GetEntries(); ++i) {
      if (!IsUsed[i]) IsUsed[i] = true;
      else  continue;

      peak = static_cast<BasePeak*> (GetPeakList()->At(i));
      if (opt.Contains("R") && !IsInRange(h, peak)) continue;

      for (Int_t j = i+1; j < GetPeakList()->GetEntries(); ++j) {
         peak2 = static_cast<BasePeak*> (GetPeakList()->At(j));
         if (opt.Contains("R") && !IsInRange(h, peak2)) continue;

         if (peak->IsPointInBkg(peak2->GetPosition()) < 1) {
            peak2->SetSignalFunction(FuncName,h);
            if (!IsUsed[j]) {
               peaks.Add(peak2);
               IsUsed[j] = true;
            }
         }
      }

      if (peaks.GetEntries() != 0)
      {
          if(FuncName == "DTGaus_Step")
          {
              FuncName = "DTGaus";
              BackOpt  = "lin";
          }

          peak->SetSignalFunction(FuncName,h);
          for(int j=0 ; j<peaks.GetEntries() ; j++)
              ((BasePeak*)peaks.At(j))->SetSignalFunction(FuncName,h);

         peak->FitCombined(h, &peaks, optFit, BackOpt);
         peaks.Clear("nodelete");
      } else {

         peak->SetSignalFunction(FuncName,h);
         peak->Fit(h,optFit, BackOpt);
      }
   }

   TIter next(&peaks); TObject *obj;
   while ( (obj = next()) ) {
      peaks.Remove(obj);
   }

   gPad->Modified();
   gPad->Update();
}


//__________________________________________________________
TH1 *BaseSpectrumPlayer::Background(Option_t* opt)
{ 
    // set bkg from current histo in pad
    TH1 *h = PadManager::GetHisto(), *result = 0x0;
    if ( h )
        result = Background(h,opt);
    if ( result ) {
        result->Draw("same");
    } // TODO Wheel Color/Style

    return result;
}

//__________________________________________________________
void BaseSpectrumPlayer::DoBackground(TH1 *histo, Option_t* opt) 
{ 
    // set bkg from histo
    TH1 *bg = Background(histo,opt);
    if ( bg ) {
        histo->Add(bg,-1.0);
        delete bg;
    }
}

//__________________________________________________________
void BaseSpectrumPlayer::SetPeakList(TSeqCollection *col) 
{ 
    // set peak list from outside
    col ? fPeakList = col : fPeakList = dynamic_cast<TSeqCollection*>(fInnerPeakList);
}

//__________________________________________________________
Bool_t BaseSpectrumPlayer::SetParameter(const char* name, const TObject *value)
{
    fLog.SetProcessMethod("SetParameter(const char*, TObject* )");

    // set parameters from list
    Bool_t ok = false;

    if ( value == 0x0 )
        return ok;

    // set search parameter
    if (strncmp(name, "DefaultPeak1D", strlen(name)) == 0 && value->InheritsFrom("Gw::BasePeak") ) {
/*              if ( fDefaultPeak1D )
            { delete fDefaultPeak1D; fDefaultPeak1D = 0x0; }
        fDefaultPeak1D =
            dynamic_cast<BasePeak *>(value->Clone());
        ok = true; */
    }
    else {
        fLog << error << "Unkown parameter " << name << nline;
    }

    fLog << dolog; return ok;
}

//__________________________________________________________
void BaseSpectrumPlayer::SetDefaultPeakFWHM(const char* name)
{
   PeakCreator* peakCreator = PeakCreator::IsPeakCreator(TVirtualPad::Pad());
   if (peakCreator) {
      peakCreator->SetDefaultPeakFWHM(name);
   } else {
      fLog.SetProcessMethod("SetDefaultPeakFWHM(const char* )");
      fLog << warning << "Peak Creator not existing in the current Pad" << dolog;
   }

}

//__________________________________________________________
Int_t BaseSpectrumPlayer::FindPeaks(Option_t* opt)
{
    // find peak method
    TH1* h = PadManager::GetHisto();
    if ( h == 0x0 ) {
        fLog.SetProcessMethod("FindPeaks(Option_t* )");
        fLog << error << "No spectrum displayed in current pad" << dolog;
        return 0;
    }
    else return FindPeaks(h,opt);
}

//__________________________________________________________
Bool_t BaseSpectrumPlayer::RenamePeak(const Char_t* baseName, Bool_t force)
{
   // rename and re-ordered peak with respect to position
   BasePeak* peak = 0x0;
   BasePeak* peak2 = 0x0;
   Int_t k = 0;

   Bool_t rename = false;
   for (Int_t i = 0; i < GetPeakList()->GetEntries(); ++i) {
      peak = static_cast<BasePeak*> (GetPeakList()->At(i));
      TString name(peak->GetName());
      for (Int_t j = i+1; j < GetPeakList()->GetEntries(); ++j) {
         peak2 = static_cast<BasePeak*> (GetPeakList()->At(j));

         if (name.CompareTo(peak2->GetName()) == 0)
             rename = true;
      }
   }

   if (!force && !rename) return false;

   TIter next(fPeakList);
   while ( (peak = (BasePeak*) next()) )  { // iterator skips empty slots
      peak->SetName( Form("%s%d", baseName, k++) );
   }
   return true;
}

//__________________________________________________________
void BaseSpectrumPlayer::AddPeak(BasePeak* peak)
{
    // add peak to list
    if ( !fPeakList->FindObject(peak) )
        fPeakList->Add(peak);
}

//__________________________________________________________
void BaseSpectrumPlayer::SortPeakList(const Char_t* parName, Bool_t sortDes)
{
  // sort peak respect to given parameter

  BasePeak* peak = 0x0;
  Int_t i = 0;
  Int_t n = fPeakList->GetEntries();

  Int_t*    index = new Int_t[n];
  Double_t* par   = new Double_t[n];

  TList* tmp = new TList();
  tmp->SetOwner(false);

  // save parameters
  TIter next(fPeakList);
  while ( (peak = (Gw::BasePeak*)next()) ) {
    if (strncmp(parName, "Position", n) == 0)
      par[i++] = peak->GetPosition();
    if (strncmp(parName, "FWHM", n) == 0)
      par[i++] = peak->GetFWHM();
    if (strncmp(parName, "Height", n) == 0)
      par[i++] = peak->GetHeight();
    tmp->AddLast(peak);
  }

  // sort in index
  TMath::Sort(n, par, index, sortDes);

  // just reset counter, no delete
  fPeakList->Clear("nodelete");

  // add again in fInnerPeakList
  for (i = 0; i < n; ++i )  {
    peak = static_cast<BasePeak*>(tmp->At(index[i]));
    fPeakList->AddLast(peak);
  }

  tmp->Clear("nodelete");
  delete tmp;
  delete[] index;
  delete[] par;
}

//__________________________________________________________
void BaseSpectrumPlayer::ShowPeakList() const 
{ 
    // re-draw peaks onto current pad
    fPeakList->AppendPad();
}

//__________________________________________________________
Int_t BaseSpectrumPlayer::CollectPeaks(Option_t* o) 
{
    // create peak list from pad
    if ( !TVirtualPad::Pad() ) {
        fLog.SetProcessMethod("CollectPeaks(Option_t* )");
        fLog << error << "Pad not existing" << dolog;
        return 0;
    }

    TString opt = o;
    if ( !opt.Contains("+") )
        fPeakList->Clear("nodelete");

    TObject *obj; Int_t i = 0;

    TIter next(TVirtualPad::Pad()->GetListOfPrimitives());
    while ( (obj = next()) ) { // iterator skips empty slots
      if ( obj->InheritsFrom("Gw::BasePeak") ) {
        if (!fPeakList->FindObject(obj)) {
//            obj->SetBit(TObject::kCanDelete, false);
//            obj->SetBit(TObject::kMustCleanup, false);
            fPeakList->Add(obj); i++;
        }
      } }

    return i;
}

//__________________________________________________________
void BaseSpectrumPlayer::Print(Option_t* opt) const
{
  // print peak info
  fPeakList->Print(opt);
}

ClassImp(BaseSpectrumPlayer)