PDataBase.cxx

Go to the documentation of this file.

/* Copyright (C) 2007-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Florian Uhlig [committer] */
 
//  Particle ID, properties and decay data base
 
#include "PDataBase.h"
 
#include "TObjArray.h"
#include "TObjString.h"
#include "TStopwatch.h"
#include "TString.h"
//#include "PMesh.h"
#include "PStdData.h"
 
PDataBase& fDataBase()
{
  static PDataBase* ans = new PDataBase();
  return *ans;
}
 
PDataBase* makeDataBase() { return &fDataBase(); }
 
 
PDataBase::PDataBase()
{
  param_double_pointer = 0;
  param_string_pointer = 0;
  param_int_pointer    = 0;
  param_tobj_pointer   = 0;
  lastkey              = 0;
 
  //Init arrays to nullptr
  for (int i = 0; i < PDATABASE_MAX_LINES; i++) {
    for (int j = 0; j < PDATABASE_MAX_STRING_PARAM; j++)
      strings[i][j] = nullptr;
    for (int j = 0; j < PDATABASE_MAX_DOUBLE_PARAM; j++)
      doubles[i][j] = nullptr;
    for (int j = 0; j < PDATABASE_MAX_INT_PARAM; j++)
      ints[i][j] = nullptr;
    for (int j = 0; j < PDATABASE_MAX_TOBJ_PARAM; j++)
      tobjs[i][j] = nullptr;
  }
 
  for (int j = 0; j < PDATABASE_MAX_INT_PARAM; j++) {
    param_int_key[j]     = nullptr;
    param_int_key_max[j] = 0;
  }
 
  MakeParamString("name", "Database name");
  //this is absolute minimum and required for testing for existence
  //    Info("PDataBase()","(%s)", PRINT_CTOR);
}
 
 
void PDataBase::Print(const Option_t*) const
{
  cout << param_int_pointer << " INT's booked (out of " << PDATABASE_MAX_INT_PARAM << ")" << endl;
  for (int i = 0; i < param_int_pointer; i++)
    cout << "INT:" << param_int_name[i] << ":" << param_int_descr[i] << endl;
 
  cout << param_double_pointer << " DOUBLE's booked (out of " << PDATABASE_MAX_DOUBLE_PARAM << ")" << endl;
  for (int i = 0; i < param_double_pointer; i++)
    cout << "DOUBLE:" << param_double_name[i] << ":" << param_double_descr[i] << endl;
 
  cout << param_string_pointer << " STRING's booked (out of " << PDATABASE_MAX_STRING_PARAM << ")" << endl;
  for (int i = 0; i < param_string_pointer; i++)
    cout << "STRING:" << param_string_name[i] << ":" << param_string_descr[i] << endl;
 
  cout << param_tobj_pointer << " TOBJ's booked (out of " << PDATABASE_MAX_TOBJ_PARAM << ")" << endl;
  for (int i = 0; i < param_tobj_pointer; i++)
    cout << "TOBJ:" << param_tobj_name[i] << ":" << param_tobj_descr[i] << endl;
}
 
void PDataBase::SetFastKey(Int_t pkey, Int_t maxkey)
{
  //set if param(pkey) provides a unique fast key
  //this is the case for e.g. "pid"
  //set the maxkey to max "pid" value
  param_int_key[pkey]     = new Int_t[maxkey];
  param_int_key_max[pkey] = maxkey;
  for (int i = 0; i < maxkey; i++)
    param_int_key[pkey][i] = -1;
}
 
Bool_t PDataBase::CheckEntry(Int_t key)
{
  //returns a kTRUE if a line with the "key" is already initialized
  if ((key >= lastkey) || (key < -1)) return kFALSE;
  //    Int_t pp=getParamString("name");
  Int_t pp = 0;
  if (strings[key][pp] == nullptr) return kFALSE;
  return kTRUE;
};
 
const char* PDataBase::GetName(Int_t key)
{
  //returns the primary name
  if ((key >= lastkey) || (key < -1)) return nullptr;
  //    Int_t pp=getParamString("name");
  Int_t pp = 0;
  return strings[key][pp];
};
 
Int_t PDataBase::MakeParamDouble(const char* paramname, const char* descr)
{
  //check maximum size
  if (param_double_pointer == PDATABASE_MAX_DOUBLE_PARAM) {
    Fatal("MakeParamDouble", "PDATABASE_MAX_DOUBLE_PARAM reached");
  }
  //check if paramname already exists
  if (GetParamDouble(paramname) >= 0) {
    Warning("MakeParamDouble", "Value %s already exists", paramname);
    return -1;
  }
  param_double_name[param_double_pointer]  = paramname;
  param_double_descr[param_double_pointer] = descr;
  param_double_pointer++;
  return param_double_pointer - 1;
}
 
 
Int_t PDataBase ::MakeParamString(const char* paramname, const char* descr)
{
  //check maximum size
  if (param_string_pointer == PDATABASE_MAX_STRING_PARAM) {
    Fatal("MakeParamString", "PDATABASE_MAX_STRING_PARAM reached");
  }
  //check if paramname already exists
  if (GetParamString(paramname) >= 0) {
    Warning("MakeParamString", "Value %s already exists", paramname);
    return -1;
  }
  param_string_name[param_string_pointer]  = paramname;
  param_string_descr[param_string_pointer] = descr;
  param_string_pointer++;
  return param_string_pointer - 1;
}
 
Int_t PDataBase ::MakeParamInt(const char* paramname, const char* descr)
{
  //check maximum size
  if (param_int_pointer == PDATABASE_MAX_INT_PARAM) { Fatal("MakeParamInt", "PDATABASE_MAX_INT_PARAM reached"); }
  //check if paramname already exists
  if (GetParamInt(paramname) >= 0) {
    Warning("MakeParamInt", "Value %s already exists", paramname);
    return -1;
  }
  param_int_name[param_int_pointer]  = paramname;
  param_int_descr[param_int_pointer] = descr;
  param_int_pointer++;
  return param_int_pointer - 1;
}
 
Int_t PDataBase ::MakeParamTObj(const char* paramname, const char* descr)
{
  //check maximum size
  if (param_tobj_pointer == PDATABASE_MAX_TOBJ_PARAM) { Fatal("MakeParamTObj", "PDATABASE_MAX_TOBJ_PARAM reached"); }
  //check if paramname already exists
  if (GetParamTObj(paramname) >= 0) {
    Warning("MakeParamTObj", "Value %s already exists", paramname);
    return -1;
  }
  param_tobj_name[param_tobj_pointer]  = paramname;
  param_tobj_descr[param_tobj_pointer] = descr;
  param_tobj_pointer++;
  return param_tobj_pointer - 1;
}
 
Int_t PDataBase ::GetParamDouble(const char* paramname)
{
  for (int i = 0; i < param_double_pointer; i++)
    if (strcmp(paramname, param_double_name[i]) == 0) return i;
  return -1;
}
 
Int_t PDataBase ::GetParamString(const char* paramname)
{
  //BUGBUG: If paramname is a pointer like "d1:name" this does not work->write getDescription
  for (int i = 0; i < param_string_pointer; i++)
    if (strcmp(paramname, param_string_name[i]) == 0) return i;
  return -1;
}
 
Int_t PDataBase ::GetParamInt(const char* paramname, Int_t length)
{
  for (int i = 0; i < param_int_pointer; i++) {
 
    if (length < 0) {
      if (strcmp(paramname, param_int_name[i]) == 0) return i;
    }
    else {
      if (strncmp(paramname, param_int_name[i], length) == 0) return i;
    }
  }
  return -1;
}
 
Int_t PDataBase ::GetParamTObj(const char* paramname)
{
  for (int i = 0; i < param_tobj_pointer; i++)
    if (strcmp(paramname, param_tobj_name[i]) == 0) return i;
  return -1;
}
 
Int_t PDataBase ::ConvertParamKey(const char*& newparamname, Int_t key)
{
  //checks for the ":" delmiter, sets the pointer to the remaing string
  //evaluate the new key
  //cout << "newparamname init " <<newparamname << endl;
  Int_t* newkey;
  for (unsigned int i = 0; i < strlen(newparamname); i++) {
    if (newparamname[i] == ':') {
      if (!GetParamInt(key, newparamname, &newkey, i)) {
        Warning("ConvertParamKey", "Value %s for key %i not existing", newparamname, key);
        return -1;
      }
      newparamname = newparamname + i + 1;
 
      return *newkey;
    }
  }
  return -1;
};
 
TString PDataBase ::GetDescription(const char* paramname)
{
  //Interpretation of pattern
  TString spattern(paramname);
  TObjArray* array = spattern.Tokenize(TString(":"));
  TString bla;
  Int_t done = 0;
  for (int pat = 0; pat < array->GetEntriesFast(); pat++) {
    if (done) bla.Append("->");
    TObjString* patoption = (TObjString*) (*array)[pat];
    char* options         = (char*) patoption->GetString().Data();
    if (GetParamString(options) > -1) {
      bla.Append(param_string_descr[GetParamString(options)]);
      done = 1;
    }
    if (GetParamInt(options) > -1) {
      bla.Append(param_int_descr[GetParamInt(options)]);
      done = 1;
    }
    if (GetParamDouble(options) > -1) {
      bla.Append(param_double_descr[GetParamDouble(options)]);
      done = 1;
    }
    if (GetParamTObj(options) > -1) {
      bla.Append(param_tobj_descr[GetParamTObj(options)]);
      done = 1;
    }
  }
  return bla;
}
 
Bool_t PDataBase ::GetParamDouble(Int_t key, const char* paramname, Double_t** result)
{
  //return kFALSE if 1.) key not existing or 2.) Param not existing or 3.) Param not used for key
  if (!CheckEntry(key)) return kFALSE;
  Int_t newkey             = -1;
  const char* newparamname = paramname;
 
  if ((newkey = ConvertParamKey(newparamname, key)) >= 0) { return GetParamDouble(newkey, newparamname, result); }
  paramname = newparamname;
  Int_t pp  = GetParamDouble(paramname);
  if (pp < 0) return kFALSE;
 
  if (doubles[key][pp] == nullptr) return kFALSE;
 
  *result = doubles[key][pp];
  return kTRUE;
};
 
Bool_t PDataBase ::GetParamDouble(Int_t key, Int_t pkey, Double_t** result)
{
  if (!CheckEntry(key)) return kFALSE;
  if (pkey < 0) return kFALSE;
  if (doubles[key][pkey] == nullptr) return kFALSE;
  *result = doubles[key][pkey];
  return kTRUE;
};
 
 
Bool_t PDataBase ::GetParamString(Int_t key, const char* paramname, const char** result)
{
  //return kFALSE if 1.) KEY not existing or 2.) Param not existing or 3.) Param not used for KEY
  if (!CheckEntry(key)) return kFALSE;
  Int_t newkey             = -1;
  const char* newparamname = paramname;
 
  if ((newkey = ConvertParamKey(newparamname, key)) >= 0) { return GetParamString(newkey, newparamname, result); }
  paramname = newparamname;
  Int_t pp  = GetParamString(paramname);
  if (pp < 0) return kFALSE;
 
  if (strings[key][pp] == nullptr) return kFALSE;
 
  *result = strings[key][pp];
  return kTRUE;
};
 
Bool_t PDataBase ::GetParamString(Int_t key, Int_t pkey, const char** result)
{
  if (!CheckEntry(key)) return kFALSE;
  if (pkey < 0) return kFALSE;
  if (strings[key][pkey] == nullptr) return kFALSE;
  *result = strings[key][pkey];
  return kTRUE;
};
 
Bool_t PDataBase ::GetParamInt(Int_t key, const char* paramname, Int_t** result, Int_t length)
{
  //return kFALSE if 1.) key not existing or 2.) Param not existing or 3.) Param not used for key
  if (!CheckEntry(key)) return kFALSE;
 
  Int_t newkey             = -1;
  const char* newparamname = paramname;
  if (length < 0) {
    if ((newkey = ConvertParamKey(newparamname, key)) >= 0) { return GetParamInt(newkey, newparamname, result); }
  }
  paramname = newparamname;
  Int_t pp  = GetParamInt(paramname, length);
  if (pp < 0) return kFALSE;
 
  if (ints[key][pp] == nullptr) return kFALSE;
 
  *result = ints[key][pp];
  return kTRUE;
};
 
Bool_t PDataBase ::GetParamInt(Int_t key, Int_t pkey, Int_t** result)
{
  if (!CheckEntry(key)) return kFALSE;
 
  if (pkey < 0) return kFALSE;
  if (ints[key][pkey] == nullptr) return kFALSE;
  *result = ints[key][pkey];
  return kTRUE;
};
 
Bool_t PDataBase ::GetParamTObj(Int_t key, const char* paramname, TObject** result)
{
  //return kFALSE if 1.) KEY not existing or 2.) Param not existing or 3.) Param not used for KEY
  if (!CheckEntry(key)) return kFALSE;
  Int_t newkey             = -1;
  const char* newparamname = paramname;
 
  if ((newkey = ConvertParamKey(newparamname, key)) >= 0) { return GetParamTObj(newkey, newparamname, result); }
  paramname = newparamname;
  Int_t pp  = GetParamTObj(paramname);
  if (pp < 0) return kFALSE;
 
  if (tobjs[key][pp] == nullptr) return kFALSE;
 
  *result = tobjs[key][pp];
  return kTRUE;
};
 
Bool_t PDataBase ::GetParamTObj(Int_t key, Int_t pkey, TObject** result)
{
  if (!CheckEntry(key)) return kFALSE;
  if (pkey < 0) return kFALSE;
  if (tobjs[key][pkey] == nullptr) return kFALSE;
  *result = tobjs[key][pkey];
  return kTRUE;
};
 
 
Bool_t PDataBase ::SetParamDouble(Int_t key, const char* paramname, Double_t* result)
{
  //return kFALSE if 1.) KEY not existing or 2.) Param not existing or 3.) Param not used for KEY
  if (!CheckEntry(key)) {
    cout << "PDataBase::SetParamDouble: key " << key << " not existing" << endl;
    return kFALSE;
  }
 
  Int_t pp = GetParamDouble(paramname);
  if (pp < 0) {
    cout << "PDataBase::SetParamDouble: paramname " << paramname << " not existing" << endl;
    return kFALSE;
  }
 
  doubles[key][pp] = result;
  return kTRUE;
};
 
Bool_t PDataBase ::SetParamString(Int_t key, const char* paramname, char* result)
{
  //return kFALSE if 1.) KEY not existing or 2.) Param not existing or 3.) Param not used for KEY
  if (!CheckEntry(key)) {
    Error("SetParamString", "key %i not existing", key);
    return kFALSE;
  }
 
  Int_t pp = GetParamString(paramname);
  if (pp < 0) {
    Error("SetParamString", "paramname %s not existing", paramname);
    return kFALSE;
  }
 
  strings[key][pp] = result;
  return kTRUE;
};
 
Bool_t PDataBase ::SetParamInt(Int_t key, const char* paramname, Int_t* result)
{
  //return kFALSE if 1.) KEY not existing or 2.) Param not existing or 3.) Param not used for KEY
  if (!CheckEntry(key)) {
    Error("SetParamInt", "key %i not existing", key);
    return kFALSE;
  }
 
  Int_t pp = GetParamInt(paramname);
  if (pp < 0) {
    Error("SetParamInt", "paramname %s not existing", paramname);
    return kFALSE;
  }
 
  ints[key][pp] = result;
  return kTRUE;
};
 
Bool_t PDataBase ::SetParamTObj(Int_t key, const char* paramname, TObject* result)
{
  //return kFALSE if 1.) KEY not existing or 2.) Param not existing or 3.) Param not used for KEY
  if (!CheckEntry(key)) {
    Error("SetParamTObj", "key %i not existing", key);
    return kFALSE;
  }
 
  Int_t pp = GetParamTObj(paramname);
  if (pp < 0) {
    Error("SetParamTObj", "paramname %s not existing", paramname);
    return kFALSE;
  }
 
  tobjs[key][pp] = result;
  return kTRUE;
};
 
Bool_t PDataBase ::SetParamTObj(Int_t key, Int_t pp, TObject* result)
{
  //return kFALSE if 1.) KEY not existing or 2.) Param not existing or 3.) Param not used for KEY
  if (!CheckEntry(key)) {
    Error("SetParamTObj", "key %i not existing", key);
    return kFALSE;
  }
 
  tobjs[key][pp] = result;
  return kTRUE;
};
 
Int_t PDataBase ::GetEntry(const char* name)
{
  for (int i = 0; i < lastkey; i++) {
    if (strings[i][0])
      if (strcmp(name, strings[i][0]) == 0) return i;
  }
  return -1;
};
 
 
Int_t PDataBase ::GetEntryInt(const char* paramname, Int_t value)
{
  Int_t* result;
  for (int i = 0; i < lastkey; i++) {
    if (GetParamInt(i, paramname, &result)) {
      if (*result == value) return i;
    }
  }
  return -1;
};
 
Int_t PDataBase ::GetEntryInt(Int_t pkey, Int_t value)
{
  //return the index key if param(pkey) is matching the value
  //otherwise -1
  Int_t* result;
 
  //use fast checking is available
  if (param_int_key[pkey]) {
    if ((value >= 0) && (value < param_int_key_max[pkey])) {
      if (param_int_key[pkey][value] != -1) { return param_int_key[pkey][value]; }
      else {
        for (int i = 0; i < lastkey; i++) {
          if (GetParamInt(i, pkey, &result)) {
            if (*result == value) {
              //cout << "init " << pkey << ":" << value << endl;
              param_int_key[pkey][value] = i;
              return i;
            }
          }
        }
      }
    }
  }
  //slow version: loop over entries
 
  for (int i = 0; i < lastkey; i++) {
    if (GetParamInt(i, pkey, &result)) {
      if (*result == value) return i;
    }
  }
  return -1;
};
 
Bool_t PDataBase ::AddEntry(Int_t key, const char* name)
{
  if (CheckEntry(key)) {
    Warning("AddEntry", "Key %i already existing", key);
    return kFALSE;
  }
  if (GetEntry(name) >= 0) {
    Warning("AddEntry", "An entry with name %s already exists", name);
    CRASH;
    return kFALSE;
  }
  Int_t pp         = GetParamString("name");
  strings[key][pp] = name;
  return kTRUE;
};
 
Int_t PDataBase ::AddEntry(const char* name)
{
  if (AddEntry(lastkey, name)) {
    lastkey++;
    return lastkey - 1;
  }
  return -1;
};
 
Int_t PDataBase::AddListEntry(const char* name, const char* count, const char* link, const char* newname)
{
  //This is used to add linked-lists the the entry "name"
  //The "count" (which should be an int param) holds the number of links
  //"link" is used for:
  //1.) setting the key to the last entry of the lists (updated on the fly)
  //2.) setting the key from the last list entry to the last-but-one
  //The first list entry points back to the original "name", thus forming a ring
  //"newname" is the name of the new list entry
 
  Int_t* i_count;
  Int_t* i_link;
  Int_t* i_newlink;
  Int_t key       = GetEntry(name);
  Int_t targetkey = GetEntry(newname);
  if (key < 0) {
    Warning("AddListEntry", "Unable to get entry %s", name);
    //Fatal("AddListEntry","Unable to get entry %s",name);
    return -1;
  }
 
  //test if linked list already initialized
  if (!GetParamInt(key, count, &i_count)) {
    //initialize
    //first add the new entry before modifying the old one
    if (targetkey < 0) targetkey = AddEntry(newname);
    if (targetkey < 0) {
      Warning("AddListEntry", "Unable to name entry %s", newname);
      return -1;
    }
    //if this worked, set the link from the new to the old entry
    //TODO: More consitency checks
 
    i_count = new Int_t(1);
    SetParamInt(key, count, i_count);
    i_link = new Int_t(targetkey);
    SetParamInt(key, link, i_link);
    i_newlink = new Int_t(key);
    SetParamInt(targetkey, link, i_newlink);
  }
  else {
    //first add the new entry before modifying the old one
    if (targetkey < 0) targetkey = AddEntry(newname);
    if (targetkey < 0) {
      Warning("AddListEntry", "Unable to name entry %s", newname);
      return -1;
    }
    //increment target count
    GetParamInt(key, count, &i_count);
    (*i_count)++;
 
    //Find the last entry in the chain
    Int_t listkey = -1, lastkey1 = -1;
    while (makeDataBase()->MakeListIterator(key, count, link, &listkey)) {
      lastkey1 = listkey;
    }
 
    //copy old pointer to new entry
    //GetParamInt (key, link,&i_link);
    GetParamInt(lastkey1, link, &i_link);
    i_newlink = new Int_t(*i_link);
    SetParamInt(targetkey, link, i_newlink);
    //set new entry
    i_link = new Int_t(targetkey);
    SetParamInt(lastkey1, link, i_link);
  }
  return targetkey;
};
 
Bool_t PDataBase ::MakeListIterator(Int_t key, const char* count, const char* link, Int_t* listkey)
{
  //get the list entries which belongs to "key" and is described by "counts" and "link"
  //(both has to be defined in a proper way)
  //It is very important that on the 1st call *listkey is -1
  //on the value kTRUE, *listkey contains the key link to the list entry
  //on the value kFALSE, the iteration has been finished (or not started due to an error)
  Int_t *i_count, *loc_listkey_p;
 
  if (key == -1) return kFALSE;
  if (*listkey == -1) {  //first call: check list header entry
    if (count) {
      if (!GetParamInt(key, count, &i_count)) {
        Warning("MakeListIterator", "count %s not found", count);
        return kFALSE;
      }
    }
    if (!GetParamInt(key, link, &loc_listkey_p)) {
      Warning("MakeListIterator", "link %s not found", link);
      return kFALSE;
    }
  }
  else {
    if (!GetParamInt(*listkey, link, &loc_listkey_p)) return kFALSE;
  }
  //now copy to external
  *listkey = *loc_listkey_p;
  if (*listkey == key) {
    *listkey = -1;
    return kFALSE;
  }
  return kTRUE;
}
 
Bool_t PDataBase ::MakeListIterator(Int_t key, Int_t count, Int_t link, Int_t* listkey)
{
  //get the list entries which belongs to "key" and is described by "counts" and "link"
  //(both has to be defined in a proper way)
  //It is very important that on the 1st call *listkey is -1
  //on the value kTRUE, *listkey contains the key link to the list entry
  //on the value kFALSE, the iteration has been finished (or not started due to an error)
  Int_t *i_count, *loc_listkey_p;
 
  if (key == -1) return kFALSE;
  if (*listkey == -1) {  //first call: check list header entry
    if (count >= 0) {
      if (!GetParamInt(key, count, &i_count)) {
        Warning("MakeListIterator", "count %i not found", count);
        return kFALSE;
      }
    }
    if (!GetParamInt(key, link, &loc_listkey_p)) {
      Warning("MakeListIterator", "link %i not found", link);
      return kFALSE;
    }
  }
  else {
    if (!GetParamInt(*listkey, link, &loc_listkey_p)) return kFALSE;
  }
  //now copy to external
  *listkey = *loc_listkey_p;
  if (*listkey == key) {
    *listkey = -1;
    return kFALSE;
  }
  return kTRUE;
}
 
 
Bool_t PDataBase ::ListEntries(Int_t key, Int_t option, const char* pattern)
{
  //key=line (or -1 for all)
  //option=0 : line break =1: no line break
  //pattern like "mass,width"
 
  Int_t start = 0;
  Int_t end   = PDATABASE_MAX_LINES - 1;
  Double_t* result;
  const char* result2;
  Int_t* result3;
  TObject* result4;
  Int_t sz[PDATABASE_MAX_LINES][PDATABASE_MAX_DOUBLE_PARAM + PDATABASE_MAX_STRING_PARAM];
  Int_t max_sz[PDATABASE_MAX_DOUBLE_PARAM + PDATABASE_MAX_STRING_PARAM];
  Int_t valid_key[PDATABASE_MAX_LINES];
 
  for (int i = 0; i < (PDATABASE_MAX_DOUBLE_PARAM + PDATABASE_MAX_STRING_PARAM); i++) {
    max_sz[i] = 0;
    for (int j = 0; j < PDATABASE_MAX_LINES; j++) {
      sz[j][i]     = 0;
      valid_key[j] = 0;
    }
  }
 
 
  //Interpretation of pattern
  TString spattern(pattern);
  TObjArray* array = spattern.Tokenize(TString(","));
 
  if (key >= 0) { start = end = key; }
  for (int run = 0; run < 2; run++) {
    //run0: check size etc.
    //run1: print info
    for (int i = start; i <= end; i++) {
      //TODO: check if at least one param is there
      if (run && valid_key[i] > 0) {
        if (option) {
          cout << i << ":";
          if (i < 10) cout << " ";
          if (i < 100) cout << " ";
          if (i < 1000) cout << " ";
        }
        else
          cout << "Database key=" << i << endl;
      }
      for (int pat = 0; pat < array->GetEntriesFast(); pat++) {
        if (pat >= (PDATABASE_MAX_DOUBLE_PARAM + PDATABASE_MAX_STRING_PARAM + PDATABASE_MAX_INT_PARAM
                    + PDATABASE_MAX_TOBJ_PARAM)) {
          //Too many string->Something is wrong
          cout << "PDataBase::listEntries: Too many pattern strings" << endl;
          return kFALSE;
        }
        TObjString* patoption = (TObjString*) (*array)[pat];
        char* options         = (char*) patoption->GetString().Data();
        Bool_t checkline      = kTRUE;
        Bool_t invert         = kFALSE;
        if (options[0] == '*') {
          //check paramteter, but not used for line selection
          options++;
          checkline = kFALSE;
        }
        if (options[0] == '!') {
          options++;
          invert = kTRUE;
        }
 
        if (GetParamDouble(i, options, &result)) {
          if (run) {
            if (valid_key[i] > 0) {
 
              if (option) cout << options << "=";
              else
                cout << GetDescription(options) << "=";
              printf("%f", *result);
              if (option) cout << " ";
              else
                cout << " \n";
            }
          }
          else {
            size_t buf_size = 1000;
            char bla[buf_size];  //I dont know a better way to get the length
            // (if somebody has an idea -> help yourself)
            int results_length = snprintf(bla, buf_size - 1, "%f", *result);
            sz[i][pat]         = results_length;
            if (sz[i][pat] > max_sz[pat]) max_sz[pat] = sz[i][pat];
            if (checkline && !invert) valid_key[i]++;
            else if (invert && checkline)
              valid_key[i] = -999;
          }
        }
 
        else if (GetParamInt(i, options, &result3)) {
          if (run) {
            if (valid_key[i] > 0) {
              if (option) cout << options << "=";
              else
                cout << GetDescription(options) << "=";
              printf("%i", *result3);
              if (option) cout << " ";
              else
                cout << " \n";
            }
          }
          else {
            size_t buf_size = 1000;
            char bla[buf_size];  //I dont know a better way to get the length
            // (if somebody has an idea -> help yourself)
            int result_length = snprintf(bla, buf_size - 1, "%i", *result3);
            sz[i][pat]        = result_length;
            if (sz[i][pat] > max_sz[pat]) max_sz[pat] = sz[i][pat];
            if (checkline && !invert) valid_key[i]++;
            else if (invert && checkline)
              valid_key[i] = -999;
          }
        }
 
        else if (GetParamString(i, options, &result2)) {
          if (run) {
            if (valid_key[i] > 0) {
              if (option) cout << options << "=" << result2;
              else
                cout << GetDescription(options) << "=" << result2;
              if (option) cout << " ";
              else
                cout << " \n";
            }
          }
          else {
            sz[i][pat] = strlen(result2);
            if (sz[i][pat] > max_sz[pat]) max_sz[pat] = sz[i][pat];
            if (checkline && !invert) valid_key[i]++;
            else if (invert && checkline)
              valid_key[i] = -999;
          }
        }
 
        else if (GetParamTObj(i, options, &result4)) {
          if (run) {
            if (valid_key[i] > 0) {
 
              if (option) cout << options << "=<yes>";
              else
                cout << GetDescription(options) << "=<yes>";
              if (option) cout << " ";
              else
                cout << " \n";
            }
          }
          else {
            sz[i][pat] = 4;  //for the yes
            if (sz[i][pat] > max_sz[pat]) max_sz[pat] = sz[i][pat];
            if (checkline && !invert) valid_key[i]++;
            else if (invert && checkline)
              valid_key[i] = -999;
          }
        }
 
        //               else if (invert && checkline) valid_key[i]++;
 
 
        if (option && run && valid_key[i] > 0) {
          //fill missing gaps
          int ga = sz[i][pat];
          //account for missing option string
          if (!ga) ga -= strlen(options) + 2;
          for (int x = ga; x < max_sz[pat]; x++) {
            cout << " ";
          }
        }
      }
 
      if (run && valid_key[i] > 0) cout << "\n";
    }
  }
  delete array;
  return kTRUE;
};
 
 
void PDataBase ::Performance(void)
{
  TStopwatch timer;
  //way1: loop over pids, and get the name
  timer.Start();
  Int_t mypid = 0, pid_param = 0, *i_result;
  for (int r = 0; r < 10000; r++)
    for (int i = 0; i < 50; i++) {
      //get the pid from name
      int k = 0;
      for (k = 0; (k < 50) && strcmp(strings[i][0], strings[k][0]); k++) {}
      mypid += k;
      //            cout << strings[i][0] << " is " << k << endl;
    }
  cout << timer.RealTime() << endl;
  cout << mypid << endl;
  mypid = 0;
 
  timer.Start();
  //now the new way
  for (int r = 0; r < 10000; r++)
    for (int i = 0; i < 50; i++) {
      GetFastParamInt("pid", &pid_param);
      if (!GetParamInt(GetEntry(strings[i][0]), pid_param, &i_result)) {
        //          if (! getFastParamInt (pid_param,i, &i_result)) {
        cout << "PStaticData::ID: " << i << " not found" << endl;
      }
      mypid += *i_result;
      //            cout << strings[i][0] << " is " << *i_result << endl;
    }
  cout << timer.RealTime() << endl;
  cout << mypid << endl;
}
 
 
ClassImp(PDataBase)