HistoConverter.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2006 by Olivier Stezowski & Christophe Theisen     *
 *   stezow(AT)ipnl.in2p3.fr, christophe.theisen(AT)cea.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_HISTOCONVERTER_H
#include "HistoConverter.h"
#endif

#ifndef GW_ENV_H
#include "Env.h"
#endif

#ifndef ROOT_TSystem
#include <TSystem.h>
#endif

#ifndef ROOT_TROOT
#include <TROOT.h>
#endif

#ifndef ROOT_TSystemDirectory
#include <TSystemDirectory.h>
#endif

#ifndef ROOT_TGMimeTypes
#include <TGMimeTypes.h>
#endif

#include <iostream>

using namespace std;
using namespace Gw;

 
// ROOT dictionnary
ClassImp(HistoConverter);


namespace { HistoConverter gHistoConverter; } // prototype ONLY use to create a new DB system

Int_t HistoConverter::fVerboseLevel = 1;
Int_t HistoConverter::gAllocated    = 0;

// static map that knows all the DB system
map<const char *, HistoConverter *>* HistoConverter::gPrototypes; 

//__________________________________________________________
HistoConverter::HistoConverter() 
:  fMode(HistoConverter::kVersion), 
   fName(""),
   fStatus(HistoConverter::kGood),      
   fError(""), 
   fCycle(';'),
   fType(""), 
   fFileExt(""),
   fIsSwapping(false),
   fOptions(""),
   fLog("HistoConverter")
{        
  if (gPrototypes == 0)
    gPrototypes = new map<const char *, HistoConverter *>;
  AddPrototype(GetType(),this); // add this to the list of known prototypes
  gAllocated++;
}

//__________________________________________________________
HistoConverter::HistoConverter(const char *name)
:  fMode(HistoConverter::kVersion), 
   fName(name),
   fStatus(HistoConverter::kGood),      
   fError(""), 
   fCycle(';'),
   fType(""), 
   fFileExt(""),
   fIsSwapping(false),
   fOptions(""),
   fLog("HistoConverter")
{               

}

//__________________________________________________________
HistoConverter::~HistoConverter()
{

  if ( gAllocated-- == 1 ) {
       clog << "HistoConverter::~HistoConverter()\n[...\n" ;
       clog << " Destroying the global prototype map ... " << endl;
       delete gPrototypes;
       clog << " done\n...]" << endl;         
   } 

}       


//__________________________________________________________
void HistoConverter::SetOption(Option_t* opt, const char* mode)
{
    TString inc(opt);

    if (!inc.EndsWith("]")) {
      inc.Append("]");
      inc.Prepend("[");
    }
    if ( strncmp(mode, "append", sizeof(opt)) == 0 ) 
      fOptions += inc;
    else if ( strncmp(mode, "reset", sizeof(opt)) == 0 ) 
      fOptions  = inc;
    else {
      fLog.GetProcessMethod() = "SetOption(Option_t*, const char* )";
      SetError(HistoConverter::kFail, Form("Unknown %s mode ", mode));
    }
}


//__________________________________________________________
void HistoConverter::SetError(HistoConverter::EStatus status, const char* msgerror) 
{ 
  fStatus = status; 
  fName   = Form("[%s::%s] ", fLog.GetProcessName().c_str(), fLog.GetProcessMethod().c_str());
  fName  += msgerror; 
  fLog << error << msgerror << dolog;   
}

//__________________________________________________________
void HistoConverter::AddPrototype(const char *type, HistoConverter *proto) 
{ 

        map<const char *, HistoConverter *>::iterator im; // iterator on the map prototype
        
        bool isnew_type = true;
        for (im = gPrototypes->begin() ; im !=   gPrototypes->end() ; im++ ) { // look if it already exists
                if ( im->first == type ) { isnew_type = false; break; }
        }
        
        if (isnew_type)  gPrototypes->insert(pair<const char *, HistoConverter *>(type, proto)); //  gPrototypes[type] = proto if not add it to the map
}

//__________________________________________________________
void HistoConverter::CheckMineTypes()
{
      Char_t type[100];
      TGMimeTypes* mineTypes = gClient->GetMimeTypeList();
      
      TString ext(fFileExt);
      ext.Prepend("*");
      Bool_t ok = mineTypes->GetType(ext.Data(), type);
      
      if (!ok)
        AddMineTypes();
}

//__________________________________________________________
void HistoConverter::AddMineTypes()
{
      TString application("[application/");
      application += fType;
      application.Append("]");
      
      TString ext(fFileExt);
      ext.Prepend("*");      
      
      TString icon(Env::GetPath("IconsPath"));
      if (!icon.EndsWith("/")) icon.Append("/");
      icon.Append("hdb_s.xpm");
            
            
      TString command;
      command = "Gw::HistoConverter::DrawSpectrum(\"%s\")";
    
      TGMimeTypes* mineTypes = gClient->GetMimeTypeList();
      
       mineTypes->AddType(application.Data(), ext.Data(), icon.Data(), icon.Data(), command.Data());
  
}

//__________________________________________________________
void HistoConverter::DrawSpectrum(const char* spectrum) 
{
      TString hname(spectrum);
      
      TH1* h;
      
      TString ext(spectrum);
      ext = ext(ext.Last('.'), ext.Length()-ext.Last('.'));
      
      map<const char *, HistoConverter *>::iterator im; // iterator on the map prototype
      
      for (im = gPrototypes->begin(); im != gPrototypes->end(); ++im ) { // look if it already exists
        if ( strncmp( im->second->GetFileExt(), ext.Data(), sizeof(im->second->GetFileExt())) == 0 ) {
          if ( strcmp(im->first,"gpsi") == 0 ) { // special traitment for gpsi            
            im->second->CheckDirectory(hname);
            im->second->ls("all");
            break;
          }
          h = im->second->Get(hname);
          h->SetDirectory(gROOT); // default wise
          h->Draw();
        }
      }
}


//__________________________________________________________
TString HistoConverter::CheckFileVersion(TString hname)
{
    
        TString filename;  // set file name as a full path name
        
        // check out the histogram name to avoid blank in a filename
        hname.ReplaceAll(" ",""); // to avoid blank in a filename
        if ( hname.EndsWith(fFileExt) ) 
                hname.Remove(hname.Last('.'));
        
        filename  = hname;  filename += fFileExt; // local file name
        
        // determine the name of the file taking into account the versionning system
        TSystemDirectory dir; 
        dir.SetDirectory(fName.Data()); TList *list = dir.GetListOfFiles();     

        if ( list ) {
                // look for the next cycle 
                int cycle;
                for ( int i = 0; i <= MAXCYCLE; i++ ) { // up to MAXCYCLE files
                
                        TString tmp;
                        if ( i == 0 ) tmp.Form("%s%s",hname.Data(), fFileExt.Data()); 
                        else tmp.Form("%s%c%d%s",hname.Data(),fCycle,i, fFileExt.Data());       
                        
                        cycle = i;
                        if ( !list->FindObject(tmp.Data()) ) { break; }
                } 
                if ( cycle == 0) { // the file doesn't exist yet 
                        filename.Form("%s%s",hname.Data(), fFileExt.Data());
                }
                if ( cycle == MAXCYCLE ) { // force overwriting even if in versionning mode
                        filename.Form("%s%c%d%s",hname.Data(),fCycle,MAXCYCLE, fFileExt.Data());        
                }
                if ( 0 < cycle && cycle < MAXCYCLE ) { 
                        if ( fMode == HistoConverter::kVersion ) // ready for a new file
                          filename.Form("%s%c%d%s",hname.Data(),fCycle,cycle, fFileExt.Data());
                        else { // comes back to the previous one
                          cycle--;
                          if ( cycle == 0 ) 
                                filename.Form("%s%s",hname.Data(), fFileExt.Data());
                          else 
                                filename.Form("%s%c%d%s",hname.Data(),fCycle,cycle, fFileExt.Data());     
                        }
                }       
          if ( gDebug > 0 )  {
            fLog.GetProcessMethod() = "CheckFileVersion(TString )";
            cerr << "Cycle is " << cycle << endl;    
          }
                delete list;
        } 
        
        return TString(filename);
   
}

//__________________________________________________________
void HistoConverter::SetVerboseLevel(const int level){
        
        if ((level != 0) && (level != 1))
                cout << "verbose level must be 0 or 1 " << endl;
        else
                HistoConverter::fVerboseLevel = level;

}

//__________________________________________________________
int HistoConverter::GetVerboseLevel(void){

        return HistoConverter::fVerboseLevel;

}

//__________________________________________________________
short HistoConverter::Short(char *buf)
{
        if ( fIsSwapping ) { 
                char c; 
                c = buf[1]; buf[1] = buf[0]; buf[0] = c;
        }
        short *s = (short*)buf; return s[0];
}

//__________________________________________________________
unsigned short HistoConverter::UShort(char *buf)
{
        if ( fIsSwapping ) { 
                char c; 
                c = buf[1]; buf[1] = buf[0]; buf[0] = c;
        }
        short *s = (short*)buf; return s[0];
}

//__________________________________________________________
long HistoConverter::Long(char *buf)
{
        if ( fIsSwapping ) { 
                char c; 
                c = buf[3]; buf[3] = buf[0]; buf[0] = c;
                c = buf[2]; buf[2] = buf[1]; buf[1] = c;        
        }
        long *s = (long*)buf; return s[0];
}

//__________________________________________________________
unsigned long HistoConverter::ULong(char *buf)
{
        if ( fIsSwapping ) { 
                char c; 
                c = buf[3]; buf[3] = buf[0]; buf[0] = c;
                c = buf[2]; buf[2] = buf[1]; buf[1] = c;                
        }
        unsigned long *s = (unsigned long*)buf; return s[0];
}

//__________________________________________________________
int HistoConverter::Int(char *buf)
{
        if ( fIsSwapping ) { 
                char c; 
                c = buf[3]; buf[3] = buf[0]; buf[0] = c;
                c = buf[2]; buf[2] = buf[1]; buf[1] = c;
        }
        int *s = (int*)buf; return s[0];
}

//__________________________________________________________
unsigned int HistoConverter::UInt(char *buf)
{
        if ( fIsSwapping ) { 
                char c; 
                c = buf[3]; buf[3] = buf[0]; buf[0] = c;
                c = buf[2]; buf[2] = buf[1]; buf[1] = c;
        }
        unsigned int *s = (unsigned int*)buf; return s[0];
}

//__________________________________________________________
float HistoConverter::Float(char *buf)
{
        if ( fIsSwapping ) { 
                char c; 
                c = buf[3]; buf[3] = buf[0]; buf[0] = c;
                c = buf[2]; buf[2] = buf[1]; buf[1] = c;
        }
        float *s = (float*)buf; return s[0];
}

//__________________________________________________________
void HistoConverter::CheckDirectory(const char *name)
{
        TString tmp, path;
        
        // Expand to set environment variables like $(HOME), and change the full path to 
        // the correct path depending on the operating system   
        tmp = name; 
        if ( tmp.Length() > 0 && tmp.EndsWith("/") == kFALSE ) tmp += "/";
        path = gSystem->UnixPathName(tmp.Data()); gSystem->ExpandPathName(path);
        
        void *dir = gSystem->OpenDirectory(path.Data());
        if ( dir == 0 ) { 
          fLog.GetProcessMethod() = "CheckDirectory(const char* )";
                SetError(HistoConverter::kZombie,
                         Form("the directory %s is not reachabled !",name));
        } else { 
          gSystem->FreeDirectory(dir); 
          fName = path.Data(); 
        }       
}

//__________________________________________________________    
void HistoConverter::ls(Option_t *) const
{
        cout << GetType() << ":" << fName << endl; 
}

//__________________________________________________________
HistoConverter *HistoConverter::NewDB(const char *name) const 
{ 
        return new HistoConverter(name);
}

//__________________________________________________________
bool HistoConverter::Read(TH1 &h)
{ 
  fLog.GetProcessMethod() = "Read(const TH1& )";
  fLog << warning << Form("Reading ROOT histogram %s in a black hole ! \n",h.GetName()) << dolog; 
  h.Reset();
  return true;
}

//__________________________________________________________
bool HistoConverter::Write(const TH1 &h)
{ 
  fLog.GetProcessMethod() = "Write(const TH1& )";
  fLog << warning << Form("Writing ROOT histogram %s in a black hole ! \n",h.GetName()) << dolog; 
  return true;
}

//__________________________________________________________
TH1* HistoConverter::Get(int /*i*/)             
{ 
  fLog.GetProcessMethod() = "Get(Int_t )";
  fLog << error << "Not implemented" << dolog; 
  return NULL; 
}  

//__________________________________________________________
TH1* HistoConverter::Get(const char* /*name*/)  
{ 
  fLog.GetProcessMethod() = "Get(const char* )";
  fLog << error << "Not implemented" << dolog;  
  return NULL; 
}