InnerNDB.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) IPNL, IN2P3, CNRS                                       *
 *   Contibutor(s) :                                                       *
 *      Jeremie Dudouet  dudouet(AT)ipnl.in2p3.fr [2014]                   *
 *      Olivier Stezowski stezow(AT)ipnl.in2p3.fr [2014]                   *
 *                                                                         *
 *   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 "TSystem.h"
#include "TString.h"
#include "TSystemDirectory.h"
#include "TList.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TDatime.h"

#include "Env.h"
#include "BashColor.h"

#include "InnerNDB.h"


using namespace Gw;
using namespace std;



InnerNDB::InnerNDB(Bool_t verbose) :
    ConcreteNDB(),
    fInnerDataBaseName("Inner"),
    fGammaSourcesName("GammaSources"),
    fListOfGammaSourceFiles(0x0),
    fVerbose(verbose)
{
    Init();
}

InnerNDB::InnerNDB(const char * name, const char * title, Bool_t verbose) :
    ConcreteNDB(name,title),
    fInnerDataBaseName("Inner"),
    fGammaSourcesName("GammaSources"),
    fListOfGammaSourceFiles(0x0),
    fVerbose(verbose)
{
    Init();
}

InnerNDB::~InnerNDB()
{

}

void InnerNDB::Init()
{
    if(!gSystem->OpenDirectory(fDataBasePath))
    {
        fBashColor->SetErrorOut();
        cout<<"[DataBaseError] Error ! DataBase path: "<<fDataBasePath<<" not found; ==> Default one \""<<Gw::Env::GetPath("NdbPath")<<"\" is taken !"<<endl;
        fDataBasePath = Gw::Env::GetPath("NdbPath");
        fBashColor->ResetColor();
    }
    else
    {
        fBashColor->SetInfoOut();
        if(fVerbose) cout<<"[DataBaseInfo] DataBase: "<<fDataBasePath<<" will be used !"<<endl;
        fBashColor->ResetColor();
    }

    fInnerDataBasePath = fDataBasePath + "/" + fInnerDataBaseName;

    if(!gSystem->OpenDirectory(fInnerDataBasePath))
    {
        fBashColor->SetErrorOut();
        cout<<"[DataBaseError] Inner DataBase path: "<<fInnerDataBaseName<<" not found in "<<fDataBasePath<<"; ==> Default one \"Inner\" is taken !"<<endl;
        fInnerDataBaseName = "Inner";
        fInnerDataBasePath = fDataBasePath + "/" + fInnerDataBaseName;
        fBashColor->ResetColor();
    }
    else
    {
        fBashColor->SetInfoOut();
        if(fVerbose) cout<<"[DataBaseInfo] "<<fInnerDataBaseName<<" DataBase: loaded !"<<endl;
        fBashColor->ResetColor();
    }

    fGammaSourcesPath = fInnerDataBasePath + "/" + fGammaSourcesName;
    if(!gSystem->OpenDirectory(fGammaSourcesPath))
    {
        fBashColor->SetWarningOut();
        cout<<"[DataBaseError] No Gamma sources directory named: "<<fGammaSourcesName<<"; ==> Default one \"GammaSources\" is taken !"<<endl;
        fGammaSourcesName = "GammaSources";
        fGammaSourcesPath = fInnerDataBasePath + "/" + fGammaSourcesName;
        fBashColor->ResetColor();
    }
    else
    {
        fBashColor->SetInfoOut();
        if(fVerbose) cout<<"[DataBaseInfo] Gamma source files are located in ${DataBase}/"<<fInnerDataBaseName<<"/"<<fGammaSourcesName<<endl;
        fBashColor->ResetColor();
        GetListOfSourceFiles();
    }

    fBashColor->ResetColor();
    cout<<flush;
}

void InnerNDB::SetInnerDataBase(TString name)
{
    fInnerDataBaseName = name;
    Init();
}

void InnerNDB::GetListOfSourceFiles()
{
    TSystemDirectory Dir;
    Dir.SetDirectory(fGammaSourcesPath);
    fListOfGammaSourceFiles = Dir.GetListOfFiles();
    fListOfGammaSourceFiles->SetName("ListOfGammaSourceFiles");
    fListOfGammaSourceFiles->Remove(fListOfGammaSourceFiles->FindObject(".")); // Pour supprimer /.
    fListOfGammaSourceFiles->Remove(fListOfGammaSourceFiles->FindObject("..")); // Pour supprimer /.
    fListOfGammaSourceFiles->Sort();
}

void InnerNDB::Print(const char *option) const
{
    TString StrOpt = option;
    if(StrOpt =="*" || StrOpt.Contains("GammaSources"))
    {
    fBashColor->SetInfoOut();
    cout<<"List of available Sources:"<<endl;
    fListOfGammaSourceFiles->Print();
    fBashColor->ResetColor();
    }
}

std::vector<GammaSourceRay *> InnerNDB::GetGammaSource(TString SourceName, double EMin, double IMin, TString Opt)
{
    TString SourceFilePath = fGammaSourcesPath + "/" + SourceName + ".sou";
    if(!gSystem->IsFileInIncludePath(SourceFilePath))
    {
        fBashColor->SetWarningOut();
        cout<<"No source file in "<<fGammaSourcesPath<<" for "<<SourceName<<" source !"<<endl;
        Print("GammaSources");
        return std::vector < Gw::GammaSourceRay* >();
        fBashColor->ResetColor();
    }

    std::ifstream FileIn;
    FileIn.open (SourceFilePath.Data(), std::ifstream::in);

    string line;
    TString Buffer;
    const char* tab = "\t";

    std::vector < Gw::GammaSourceRay* > ListOfGammas;

    while(FileIn)
    {
        getline(FileIn,line);
        Buffer = line;

        if(Buffer=="")break;
        if(Buffer.BeginsWith("#") || Buffer.BeginsWith("A")) continue;

        Int_t i=0;
        TString toto[20];
        TObjArray *loa=Buffer.Tokenize(tab);
        TIter next(loa);
        TObjString *os=0;
        while((os=(TObjString *)next()))
        {
            toto[i] = os->GetString();
            i++;
        }

        TString DecayMode = toto[4].ReplaceAll(" ","").ReplaceAll(tab,"");
        TString Daughter  = toto[7].ReplaceAll(" ","").ReplaceAll(tab,"");
        TString RadSubType = toto[9].ReplaceAll(" ","").ReplaceAll(tab,"");
        double LifeTime = toto[6].ReplaceAll(" ","").ReplaceAll(tab,"").Atof();
        double E = toto[10].ReplaceAll(" ","").ReplaceAll(tab,"").Atof();
        double dE = toto[11].ReplaceAll(" ","").ReplaceAll(tab,"").Atof();
        double I = toto[14].ReplaceAll(" ","").ReplaceAll(tab,"").Atof();
        double dI = toto[15].ReplaceAll(" ","").ReplaceAll(tab,"").Atof();

        if(E<EMin) continue;
        if(I<IMin) continue;
        if(Opt.Contains("NoXR") && RadSubType.Contains("XR")) continue;

//        cout<<DecayMode<<tab<<Daughter<<tab<<RadSubType<<tab<<LifeTime<<tab<<E<<tab<<dE<<tab<<I<<tab<<dI<<endl;

        GammaSourceRay *Gamma = new GammaSourceRay(Form("%s_%.0lf",SourceName.Data(),E),Form("%s_%.0lf",SourceName.Data(),E));
        Gamma->Emmiter = SourceName;
        Gamma->Daughter = Daughter;
        Gamma->DecayMode = DecayMode;
        Gamma->RadSubType = RadSubType;

        Gw::Measure<Double_t> *LifeTimeMeas;
        LifeTimeMeas = new Gw::Measure<Double_t>();
        LifeTimeMeas->SetValue(LifeTime);
        LifeTimeMeas->SetError(0.);

        Gamma->LifeTime = LifeTimeMeas;

        Gw::Measure<Double_t> *IntensityMeas;
        IntensityMeas = new Gw::Measure<Double_t>();
        IntensityMeas->SetValue(I);
        IntensityMeas->SetError(dI);

        Gamma->Intensity = IntensityMeas;

        Gw::Measure<Double_t> *EnerMeas;
        EnerMeas = new Gw::Measure<Double_t>();
        EnerMeas->SetValue(E);
        EnerMeas->SetError(dE);

        Gamma->Energy = EnerMeas;

        ListOfGammas.push_back(Gamma);
    }

    return ListOfGammas;
}

void InnerNDB::SaveGammaList(TString ListName, std::vector <double> Energies)
{
    TString FileName = fInnerDataBasePath + "/" + ListName + ".peaklist";

    std::ofstream FileOut(FileName.Data());

    FileOut<<"#List of gamma named : "<<ListName<<endl;
    TDatime date;
    FileOut<<"#created on : "<<date.AsString()<<endl;
    for(unsigned int i=0 ; i<Energies.size() ; i++)
    {
        FileOut<<Energies[i]<<endl;
    }
    FileOut.close();

    fBashColor->SetInfoOut();
    cout<<"Peak list saved in "<<FileName<<endl;
    fBashColor->ResetColor();
}

std::vector <double> InnerNDB::LoadGammaList(TString ListName)
{
    TString FileName = fInnerDataBasePath + "/" + ListName + ".peaklist";

    std::vector <double> Energies;

    if(!gSystem->IsFileInIncludePath(FileName))
    {
        fBashColor->SetWarningOut();
        cout<<FileName<<" not found !"<<endl;
        fBashColor->SetInfoOut();
        cout<<"Here are the available gamma lists files in the "<<fInnerDataBasePath<<" directory"<<endl;
        TSystemDirectory Dir;
        Dir.SetDirectory(fInnerDataBasePath);
        TList *l = Dir.GetListOfFiles();
        l->Sort();
        for(int i=0 ; i<l->GetSize() ; i++)
        {
            if(((TString)l->At(i)->GetName()).EndsWith(".peaklist"))
            {
                cout<<((TString)l->At(i)->GetName()).ReplaceAll(".peaklist","")<<endl;
            }
        }
        fBashColor->ResetColor();
        return Energies;
    }

    std::ifstream FileIn(FileName.Data());

    string line;
    TString Buffer;

    while(FileIn)
    {
        getline(FileIn,line);
        Buffer = line;
        if(Buffer=="") break;
        double E = Buffer.Atof();
        if(E!=0) Energies.push_back(E);
    }

    fBashColor->SetInfoOut();
    cout<<FileName<<" loaded !"<<endl;
    fBashColor->ResetColor();

    return Energies;
}

ClassImp(InnerNDB);