PDataBase.h

Go to the documentation of this file.

/* Copyright (C) 2007-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: I. Froehlich, Florian Uhlig [committer] */
 
// Author: I. Froehlich
// Written: 11.04.2007
// Revised:
// PDataBase
// Replacement for the particle data base in PData
 
#ifndef _PDATABASE_H_
#define _PDATABASE_H_
 
#include "TROOT.h"
 
#include <iostream>
 
#include "Pdefines.h"
 
#define PDATABASE_MAX_DOUBLE_PARAM 20
#define PDATABASE_MAX_STRING_PARAM 20
#define PDATABASE_MAX_INT_PARAM 150
#define PDATABASE_MAX_TOBJ_PARAM 10
 
#define PDATABASE_MAX_LINES 1000
 
using namespace std;
 
class PDataBase;
PDataBase* makeDataBase();
PDataBase& fDataBase();
 
class PDataBase : public TObject {
 
private:
  //Entries properties
  const char* param_double_name[PDATABASE_MAX_DOUBLE_PARAM];  //the parameter name matching the ID
  const char* param_string_name[PDATABASE_MAX_STRING_PARAM];
  const char* param_int_name[PDATABASE_MAX_INT_PARAM];
  const char* param_tobj_name[PDATABASE_MAX_INT_PARAM];
  const char* param_double_descr[PDATABASE_MAX_DOUBLE_PARAM];  //the parameter long description
  const char* param_string_descr[PDATABASE_MAX_STRING_PARAM];
  const char* param_int_descr[PDATABASE_MAX_INT_PARAM];
  const char* param_tobj_descr[PDATABASE_MAX_INT_PARAM];
  Int_t param_double_pointer;
  Int_t param_string_pointer;
  Int_t param_int_pointer;
  Int_t param_tobj_pointer;
 
  //TODO: Params need description
 
  Int_t* param_int_key[PDATABASE_MAX_INT_PARAM];
  Int_t param_int_key_max[PDATABASE_MAX_INT_PARAM];
 
  //The entries array itself
  //for each entry, we add the pointer array to our params
  const char* strings[PDATABASE_MAX_LINES][PDATABASE_MAX_STRING_PARAM];
  Double_t* doubles[PDATABASE_MAX_LINES][PDATABASE_MAX_DOUBLE_PARAM];
  Int_t* ints[PDATABASE_MAX_LINES][PDATABASE_MAX_INT_PARAM];
  TObject* tobjs[PDATABASE_MAX_LINES][PDATABASE_MAX_TOBJ_PARAM];
 
  Int_t lastkey;
 
  Bool_t CheckEntry(Int_t key);  //check if key with unique name already existing
  Int_t ConvertParamKey(const char*& newparamname, Int_t key);
 
public:
  //constructor
  PDataBase();
 
  void Performance(void);
 
  void SetFastKey(Int_t pkey, Int_t maxkey);
 
  //return value of the makeParam's: the param_id of -1 on failure
  Int_t MakeParamDouble(const char* paramname,
                        const char* descr);  //add "paramname" to double database
  Int_t MakeParamString(const char* paramname,
                        const char* descr);  //add "paramname" to string database
  Int_t MakeParamInt(const char* paramname,
                     const char* descr);  //add "paramname" to int database
  Int_t MakeParamTObj(const char* paramname,
                      const char* descr);  //add "paramname" to object database
 
  Int_t GetParamDouble(const char* paramname);  //get "paramname" from double database
  Int_t GetParamString(const char* paramname);  //get "paramname" from string database
  Int_t GetParamInt(const char* paramname,
                    Int_t length = -1);  //get "paramname" from string database
  Int_t GetParamTObj(const char* paramname);
 
  TString GetDescription(const char* paramname);
 
  void GetFastParamInt(const char* paramname, Int_t* pkey)
  {
    if ((*pkey) < 0) *pkey = GetParamInt(paramname);
  };
  void GetFastParamString(const char* paramname, Int_t* pkey)
  {
    if ((*pkey) < 0) *pkey = GetParamString(paramname);
  };
  void GetFastParamDouble(const char* paramname, Int_t* pkey)
  {
    if ((*pkey) < 0) *pkey = GetParamDouble(paramname);
  };
  void GetFastParamTObj(const char* paramname, Int_t* pkey)
  {
    if ((*pkey) < 0) *pkey = GetParamTObj(paramname);
  };
 
  using TObject::GetName;
  const char* GetName(Int_t key);
  //getting particle/decay properties from data base
  //return kFALSE if 1.) key not existing or 2.) Param not existing or 3.) Param not used for entry
  Bool_t GetParamDouble(Int_t key, const char* paramname, Double_t** result);
  Bool_t GetParamString(Int_t key, const char* paramname, const char** result);
  Bool_t GetParamInt(Int_t key, const char* paramname, Int_t** result, Int_t length = -1);
  Bool_t GetParamTObj(Int_t key, const char* paramname, TObject** result);
 
  //same as above but with the pkey as obtained by the getFastParam's
  Bool_t GetParamInt(Int_t key, Int_t pkey, Int_t** result);
  Bool_t GetParamString(Int_t key, Int_t pkey, const char** result);
  Bool_t GetParamDouble(Int_t key, Int_t pkey, Double_t** result);
  Bool_t GetParamTObj(Int_t key, Int_t pkey, TObject** result);
 
  //setting value instead of pointer
  Bool_t GetParamInt(Int_t key, Int_t pkey, Int_t* result)
  {
    Int_t* p;
    Bool_t b = GetParamInt(key, pkey, &p);
    if (b && p) *result = *p;
    else
      *result = 0;
    return b;
  };
 
  //getting param by primary name
  Bool_t GetParamInt(const char* name, const char* paramname, Int_t** result)
  {
    return GetParamInt(GetEntry(name), paramname, result);
  };
  Bool_t GetParamDouble(const char* name, const char* paramname, Double_t** result)
  {
    return GetParamDouble(GetEntry(name), paramname, result);
  };
  Bool_t GetParamString(const char* name, const char* paramname, const char** result)
  {
    return GetParamString(GetEntry(name), paramname, result);
  };
  Bool_t GetParamTObj(const char* name, const char* paramname, TObject** result)
  {
    return GetParamTObj(GetEntry(name), paramname, result);
  };
 
  //Getting param by matching integer value
  Bool_t GetParamInt(const char* paramname1, Int_t value1, const char* paramname2, Int_t** result)
  {
    return GetParamInt(GetEntryInt(paramname1, value1), paramname2, result);
  };
  Bool_t GetParamDouble(const char* paramname1, Int_t value1, const char* paramname2, Double_t** result)
  {
    return GetParamDouble(GetEntryInt(paramname1, value1), paramname2, result);
  };
  Bool_t GetParamString(const char* paramname1, Int_t value1, const char* paramname2, const char** result)
  {
    return GetParamString(GetEntryInt(paramname1, value1), paramname2, result);
  };
  Bool_t GetParamTObj(const char* paramname1, Int_t value1, const char* paramname2, TObject** result)
  {
    return GetParamTObj(GetEntryInt(paramname1, value1), paramname2, result);
  };
 
  //same as above when the pkey are known...
  Bool_t GetParamInt(Int_t pkey1, Int_t value1, Int_t pkey2, Int_t** result)
  {
    //  cout << pkey1 << ":" << value1<< ":" << pkey2<< ":" << endl;
    return GetParamInt(GetEntryInt(pkey1, value1), pkey2, result);
  };
  Bool_t GetParamDouble(Int_t pkey1, Int_t value1, Int_t pkey2, Double_t** result)
  {
    return GetParamDouble(GetEntryInt(pkey1, value1), pkey2, result);
  };
  Bool_t GetParamString(Int_t pkey1, Int_t value1, Int_t pkey2, const char** result)
  {
    return GetParamString(GetEntryInt(pkey1, value1), pkey2, result);
  };
  Bool_t GetParamTObj(Int_t pkey1, Int_t value1, Int_t pkey2, TObject** result)
  {
    return GetParamTObj(GetEntryInt(pkey1, value1), pkey2, result);
  };
 
 
  Bool_t SetParamDouble(Int_t key, const char* paramname, Double_t* result);
  Bool_t SetParamString(Int_t key, const char* paramname, char* result);
  Bool_t SetParamInt(Int_t key, const char* paramname, Int_t* result);
  Bool_t SetParamTObj(Int_t key, const char* paramname, TObject* result);
 
  //faster:
  Bool_t SetParamTObj(Int_t key, Int_t pp, TObject* result);
 
  Bool_t SetParamDouble(const char* name, const char* paramname, Double_t result)
  {
    Int_t key = GetEntry(name);
    if (key < 0) return kFALSE;
    return SetParamDouble(key, paramname, new Double_t(result));
  }
  Bool_t SetParamInt(const char* name, const char* paramname, Int_t result)
  {
    Int_t key = GetEntry(name);
    if (key < 0) return kFALSE;
    return SetParamInt(key, paramname, new Int_t(result));
  }
  Bool_t SetParamString(const char* name, const char* paramname, char* result)
  {
    Int_t key = GetEntry(name);
    if (key < 0) return kFALSE;
    return SetParamString(key, paramname, result);
  };
  Bool_t SetParamTObj(const char* name, const char* paramname, TObject* result)
  {
    Int_t key = GetEntry(name);
    if (key < 0) return kFALSE;
    return SetParamTObj(key, paramname, result);
  };
 
  //Dealing with the entries
  Bool_t AddEntry(Int_t key, const char* name);
  Int_t AddEntry(const char* name);
  Int_t GetEntry(const char* name);
  Int_t GetEntryInt(const char* paramname, Int_t value);
  Int_t GetEntryInt(Int_t pkey, Int_t value);
 
  //listings
  Int_t AddListEntry(const char* name, const char* count, const char* link, const char* newname);
  Bool_t MakeListIterator(Int_t key, const char* count, const char* link, Int_t* listkey);
  Bool_t MakeListIterator(Int_t key, Int_t count, Int_t link, Int_t* listkey);
 
  Bool_t ListEntries(Int_t key = -1, Int_t option = 0, const char* pattern = nullptr);
 
  void Print(const Option_t* delme) const;
 
 
  ClassDef(PDataBase, 0);  //Relational data base for pluto
};
 
#endif