TridControl.cxx

Go to the documentation of this file.

#include "TridControl.h"
#include "TridModel.h"
#include "TridPage.h"

#include "MessageService/MsgService.h"
#include "Midad/Base/PageDisplay.h"
#include "Conventions/Munits.h"
// SigC:
#include <sigc++/sigc++.h>
#include <sigc++/class_slot.h>

// Root stuff:
#include <TStyle.h>
#include <TColor.h>
#include <TROOT.h>
#include <TSystem.h>
#include <TFile.h>
#include <TTimer.h>
#include <TEnv.h>
#include <TOrdCollection.h>
#include <THashList.h>

#include <math.h>
#include <algorithm>

class SelectionInfoPage;

using namespace std;

CVSID("$Id: TridControl.cxx,v 1.26 2007/02/01 22:24:00 rhatcher Exp $");
using namespace SigC;


// Mode names.
const char* kColorModeNames[TridControl::kNumColorModes] = 
  {
    "Charge (MIPs)",
    "Charge (ADC Counts)",
    "Charge (PEs)",
    "Mean Time (raw) (ns)",
    "Mean Time (-t0) (ns)",
    "Earliest Time (raw) (ns)",
    "Earliest Time (-t0) (ns)",
    "Occupancy"
  };

const char* kTransModeNames[TridControl::kNumTransModes] = 
  {
    "None",
    "Constant",
    "Charge (MIPs)",
    "Charge (ADC Counts)",
    "Charge (PEs)",
    "Mean Time (raw) (ns)",
    "Mean Time (-t0) (ns)",
  };


const double kColorModeStartRanges[TridControl::kNumColorModes][2] = 
   {{ 0, 20   },
    { 0, 2000 },
    { 0, 20   },
    { 0, 200  },
    { 0, 200  },
    { 0, 200  },
    { 0, 200  },
    { 0, 4    }
  };

const double kTransModeStartRanges[TridControl::kNumTransModes][2] = 
  { { 0, 1.2  },
    { 0, 1.2, },
    { 0, 20 },
    { 0, 2000 },
    { 0, 20 },
    { 0, 200 },
    { 0, 200 },
  };

ClassImp(TridControl)

// Static members.
map<PageDisplay*,TridControl*> TridControl::sControls;

// Constructor, destructor

TridControl::TridControl(PageDisplay* pd): 
  fPageDisplay(pd),
  fMenu(0),
  fHistoMenu(0),
  fCurrentHistoName(""),
  fPick(0),
  fSelection(),
  fColorMode(kColorAsChargeADC),
  fTransMode(kTransConstant),  
  fColorShowUnderScale(true), 
  fColorShowOverScale(true),
  fInterpolateColor(true),
  fForegroundColor(1,1,1), // White
  fBackgroundColor(0,0,0), // Black
  fSelectionInfoPage(0),
  fAnimator(*this)
{
  const char* confFile = gSystem->Getenv("TRID_CONFIG_FILE");
  if(confFile) {
    MSG("TriD",Msg::kInfo) << "Loading config data from " << confFile << endl;
    fConfigFileName = confFile;
  }
  else 
    fConfigFileName = ".tridrc";

  sControls[fPageDisplay] = this;
  MSG("TriD",Msg::kDebug) << "TridControl Constructor!" << endl;

  // Look for the TriD menu, common to all Pages in the PD.
  GuiMenuBar& mb = fPageDisplay->GetMenuBar();
  GuiMenu* fMenu = mb.GetMenu("TriD");
  GuiMenu::GuiMenuList::iterator mit;
  
  if(fMenu) {
    MSG("TriD",Msg::kError) << "TridControl Constructor: Menu already exists in PageDisplay!" << endl;
    return; 
  }

  // Setup the trid menu(s).
  fMenu = mb.MakeAddMenu("TriD");
  
  mit = fMenu->Add("Animation...");
  (*mit)->Connect(slot_class(fAnimator,&TridAnimator::OpenWindow));

  // Histograms.
  fHistoMenu = manage(new GuiMenu);
  fMenu->Add("Histograms",*fHistoMenu);

  // Switches.
   
  // Over and underscale options.
  fColorShowUnderScale.AddToMenu(fMenu,"Show Underscale (color)");
  fColorShowOverScale. AddToMenu(fMenu,"Show Overscale (color)");
  // When hit, change the color.
  fColorShowUnderScale.Connect(fSignal_ChangeColor.slot());
  fColorShowOverScale.Connect(fSignal_ChangeColor.slot()); 

  // Window menu.
  //fWindowMenu = manage(new GuiMenu);
  //fMenu->Add("Windows",*fWindowMenu);
  mit = fMenu->Add("Save Configuration");
  (*mit)->Connect(slot_class(*this,&TridControl::SaveWindowGeometries));
  mit = fMenu->Add("Restore Configuration");
  (*mit)->Connect(slot_class(*this,&TridControl::RestoreWindowGeometries));


  // Set up the default ranges.

  // Put in some values for all of them, just to cover my ass.
  for(int i=0;i<kNumColorModes;i++) {
    fColorRanges[i].SetName(kColorModeNames[i]);
    fColorRanges[i].Set(
                               kColorModeStartRanges[i][0],
                               kColorModeStartRanges[i][1]
                               );
  }

  for(int i=0;i<kNumTransModes;i++) {
    fColorRanges[i].SetName(kColorModeNames[i]);
    fTransRanges[i].Set(
                               kTransModeStartRanges[i][0],
                               kTransModeStartRanges[i][1]
                               );
  }
  
}


TridControl::~TridControl()
{
  // Object is destroyed by the usual SigC mechanism:
  // When all pages which track instance drop it,
  // it destroys itself.
  MSG("TriD",Msg::kDebug) << "~TridControl()" << endl;

  sControls[fPageDisplay] = 0;
}
 
// Access
   
TridControl* 
TridControl::Instance(PageDisplay* pd) 
{
  // Get a trid control pointer.
  if(sControls[pd]!=0) return sControls[pd];
  TridControl* control = manage(new TridControl(pd));
  return control;
}

// Page registration.
void TridControl::ConnectTridPage(TridPage* page)
{
  // Connects each signal to the corresponding slot on the Page.
  // Adds the connection for each signal to a map so that the 
  // slot can be deleted when the page is.
  std::vector<Connection> list;
  list.push_back(fSignal_ChangeColor.connect     ((slot_class(*page,&TridPage::ChangeColorHook)    )));
  list.push_back(fSignal_ChangeTrans.connect     ((slot_class(*page,&TridPage::ChangeTransHook)    )));
  list.push_back(fSignal_ChangePicked.connect    ((slot_class(*page,&TridPage::ChangePickedHook)   )));
  list.push_back(fSignal_ChangeSelected.connect  ((slot_class(*page,&TridPage::ChangeSelectedHook) )));
  list.push_back(fSignal_ChangeHistograms.connect((slot_class(*page,&TridPage::ChangeHistogramsHook) )));
  list.push_back(fSignal_Animation.connect       ((slot_class(*page,&TridPage::AnimationHook) )));
  list.push_back(fSignal_SaveWindowGeometry.connect   ((slot_class(*page,&TridPage::SaveWindowGeometry) )));
  list.push_back(fSignal_RestoreWindowGeometry.connect((slot_class(*page,&TridPage::RestoreWindowGeometry) )));
  for(UInt_t i = 0; i<list.size(); i++) {
    fConnections.insert(pair<TridPage*,Connection>(page,list[i]));
  }
}
void TridControl::DisconnectTridPage(TridPage* page)
{
  typedef std::multimap<TridPage*,Connection>::iterator my_it;
  pair<my_it,my_it> range;
  range = fConnections.equal_range(page);
  for(my_it it = range.first; it != range.second; it++) {
    it->second.disconnect();
  }

}


// Histograms.

void TridControl::AddHistograms(const char* pageName, TH1* colorhist, TH1* transhist )
{
  string s(pageName);
  fColorHistograms[s] = colorhist;
  fTransHistograms[s] = transhist;  
 
  // Update menu.
  GuiMenu::GuiMenuList::iterator mit;
  mit = fHistoMenu->Add(pageName);
  (*mit)->Connect(bind(bind(bind(slot_class(*this,&TridControl::HistoMenuHandler),
                                 s), mit), fHistoMenu));
  if(fCurrentHistoName=="") {
    fHistoMenu->CheckEntry(mit);
    fCurrentHistoName=s;
  }
}

TH1*   TridControl::GetColorHistogram()
{
  return fColorHistograms[fCurrentHistoName];
}

TH1*   TridControl::GetTransHistogram()
{
  return fTransHistograms[fCurrentHistoName];
}

void TridControl::HistoMenuHandler(GuiMenu* menu, 
                                   GuiMenu::GuiMenuList::iterator mit,
                                   string item )
{
  // Set checkmarks appropriately.
  GuiMenu::GuiMenuList& mlist = menu->GetMenuList();
  GuiMenu::GuiMenuList::iterator it, done = mlist.end();
  for (it = mlist.begin(); it != done; ++it)
    menu->CheckEntry(it,false);
  menu->CheckEntry(mit,true);
  fCurrentHistoName=item;
  fSignal_ChangeHistograms.emit();
}




// Color
void TridControl::ChangeColorMode( int mode )
{
  MSG("TriD",Msg::kDebug) << "Color mode change requested to " << mode  << endl;
  if((mode < kNumColorModes) ) {
    fColorMode.SetState(mode);
    fSignal_ChangeColor.emit();
  }
}

void TridControl::ChangeColorRange( double min, double max )
{
  fColorRanges[fColorMode()].Set(min,max);
  fSignal_ChangeColor.emit();
}

void TridControl::GetColorRange( double &min, double &max )
{
  min = fColorRanges[fColorMode()].Min();
  max = fColorRanges[fColorMode()].Max();
}

const char* TridControl::GetColorModeName()
{
  return kColorModeNames[fColorMode()];
}



// Trans
void TridControl::ChangeTransMode( int mode )
{
  MSG("TriD",Msg::kDebug) << "Trans mode change requested to " << mode  << endl;
  if((mode < kNumTransModes) ) {
    fTransMode.SetState(mode);

    fSignal_ChangeTrans.emit();
  }
}

void TridControl::ChangeTransRange( double min, double max )
{
  fTransRanges[fTransMode()].Set(min,max);
  fSignal_ChangeTrans.emit();
}

void TridControl::GetTransRange( double &min, double &max )
{
  min = fTransRanges[fTransMode()].Min();
  max = fTransRanges[fTransMode()].Max();
}

const char* TridControl::GetTransModeName()
{
  return kTransModeNames[fTransMode()];
}



// Options and switches

void TridControl::SaveWindowGeometries() 
{
  
  TEnv env(fConfigFileName.Data());
  env.SetValue("Trid.DefaultWindows","",kEnvChange); // Set up null string.
  fSignal_SaveWindowGeometry.emit(env);

  // This line doesn't work because the ROOT Env system has bugs.
  //env.SaveLevel(kEnvUser);

  // So, I'll write my own custom save routine here:
  TIter next(env.GetTable());
  TEnvRec* er;
  FILE* outfile = fopen(fConfigFileName.Data(),"w+");
  if(!outfile) return;
  while((er= (TEnvRec*) next())) {
    const char* val = env.GetValue(er->GetName(),"");
    fprintf(outfile, "%-40s %s\n", 
            Form("%s:", er->GetName()),
            val );
  }
  fclose(outfile);
  
}

void TridControl::RestoreWindowGeometries() 
{
  //char *s = gSystem->ConcatFileName(gSystem->HomeDirectory(), ".tridrc");
  TEnv env(fConfigFileName.Data());  
  fSignal_RestoreWindowGeometry.emit(env);
}

// Picking and Selecting

bool TridControl::IsPicked(const TridModel* model)
{
  if(fPick)
    if(fPick->Intersects(model)) return true;
  return false;
}

void TridControl::ClearSelected()
{
  fSelection.clear();
}

void TridControl::ToggleSelected(const TridModel* model) 
{
  std::set<const TridModel*>::iterator it;
  it = fSelection.find(model);
  if(it==fSelection.end()) {
    fSelection.insert(model);
  } else {
    fSelection.erase(it);
  }
}

Bool_t TridControl::IsSelected(const TridModel* model)
{
  std::set<const TridModel*>::iterator it = fSelection.begin();
  std::set<const TridModel*>::iterator end= fSelection.end();
  for( ; it!=end; it++ ) {
    if( (*it)->Intersects(model) ) return true;
  }

  return false;
}



// Color stuff.
// color mapping
TVector3 TridControl::GetColor( Float_t x ) 
{
  // Map a fractional number x to a place in the current pallete.
  // Underscale:
  int n = gStyle->GetNumberOfColors();
  int index = (int)(floor((x*(float)n)));
  if(index>=n) index = n-1;
  if(index<0) index = 0;
  int colNum = gStyle->GetColorPalette(index);
  TColor* colref = gROOT->GetColor(colNum);
  TVector3 rgb(colref->GetRed(),colref->GetGreen(),colref->GetBlue());

  // Underscale and overscale: make whiter.
  if((x<.00) || (x>1.0)) {
    rgb = rgb + TVector3(.4,.4,.4);
    if(rgb.x()>1) rgb.SetX(1);
    if(rgb.y()>1) rgb.SetY(1);
    if(rgb.z()>1) rgb.SetZ(1);
    return rgb;
  }

  if(!fInterpolateColor) {
    return rgb;
  }
  if(index+1>=n) return rgb;
  int colNum2 = gStyle->GetColorPalette(index+1);
  TColor* colref2 = gROOT->GetColor(colNum2);
  TVector3 rgb2(colref2->GetRed(),colref2->GetGreen(),colref2->GetBlue());
  double frac = fmod(x*(double)n,1.0);
  TVector3 interp = (1.0-frac)*rgb + (frac)*rgb2;
  return interp;
}


// Color and Trans model mapping.
Double_t TridControl::GetRangedModelColor(TridModel* model)
{
  double x = 0;

  switch(fColorMode()) {
  case kColorAsChargeMIP:
    x = model->GetTotalCharge(CalStripType::kSigCorr);
    break;
        
  case kColorAsChargeADC:
    x = model->GetTotalCharge(CalStripType::kNone);
    break;
    
  case kColorAsChargePE:
    x = model->GetTotalCharge(CalStripType::kPE);
    break;

  case kColorAsTimeMean:
    x = model->GetMeanTime(CalTimeType::kNone)/Munits::nanosecond;
    break;

  case kColorAsTimeMeanT0:
    x = model->GetMeanTime(CalTimeType::kT0)/Munits::nanosecond;
    break;

  case kColorAsTimeEarliest:
    x = model->GetEarliestTime(CalTimeType::kNone)/Munits::nanosecond;
    break;

  case kColorAsTimeEarliestT0:
    x = model->GetEarliestTime(CalTimeType::kT0)/Munits::nanosecond;
    break;
    
  case kColorAsOccupancy:
    x = model->GetOccupancy();
    break;

  default:
    MSG("TriD",Msg::kError) << "Color mode not implimented!" << endl;
  }

  // Transform to current scale and get color.
  return fColorRanges[fColorMode()].RelativeUnclipped(x);
}

Double_t TridControl::GetRangedModelTrans( TridModel* model )
{
  Float_t x = 1.0;
  switch(fTransMode()) {
  case kTransNone: return 1.0;
  case kTransConstant:   
    x = 1.0;
    break;
  case kTransAsChargeMIP:
    x = model->GetTotalCharge(CalStripType::kSigCorr);
    break;
  case kTransAsChargeADC:
    x = model->GetTotalCharge(CalStripType::kNone);
    break;
  case kTransAsChargePE:
    x = model->GetTotalCharge(CalStripType::kPE);
    break;
  case kTransAsMeanTime:
    x = model->GetMeanTime(CalTimeType::kNone)/Munits::nanosecond;
    break;
  case kTransAsMeanTimeT0:
    x = model->GetMeanTime(CalTimeType::kT0)/Munits::nanosecond;
    break;
  default:
    MSG("TriD",Msg::kError) << "Trans mode not implimented!" << endl;
  }
  
  return fTransRanges[fTransMode()].RelativeUnclipped(x);
}

// Animation.


// File operations.
/*
const char kDefaultFilename[] = {"~/.tridrc"};

void TridControl::LoadFromFile( const char* filename )
{
  TString file = kDefaultFilename;
  if(strlen(filename)>0) file = filename;
  gSystem->ExpandPathName(file);
  if(gSystem->AccessPathName(file.Data())) {
    TFile f(file.Data());
    TridControl* obj = (TridControl*) f.Get("TridControl");
    Copy(*obj);
    delete obj;
    f.Close();
  }
}

void TridControl::SaveToFile( const char* filename )
{
  TString file = kDefaultFilename;
  if(strlen(filename)>0) file = filename;
  gSystem->ExpandPathName(file);
  TDirectory* cd_save = gDirectory;
  TFile f(file.Data(),"RECREATE");
  f.cd();
  Write("TridControl");
  f.Write();
  f.Close();
  cd_save->cd();
}
*/

---