// Author: IF
// Written: 25.05.2007
// Revised: 
// PDynamicData Class Header

#ifndef _PDYNAMICDATA_H_
#define _PDYNAMICDATA_H_

#define MAX_PCHANNEL_OBJECTS 10000

#include "TROOT.h"
#include "TF1.h"
#include <iostream>

#include "PDataBase.h"
#include "PDistribution.h"
#include "PMesh.h"
#include "PChannelModel.h"
#include "PParticle.h"


class PDynamicData;
PDynamicData *makeDynamicData();
PDynamicData &fDynamicData();

class PDynamicData : public TObject {
      
 public:

    PDynamicData();

    //**** Decays
    Double_t GetDecayPartialWidth(Double_t mass,Int_t didx);
   
    PChannelModel *GetDecayModel(Int_t didx);
    PChannelModel *GetDecayModelByKey(Int_t key);
    PChannelModel *GetDecayModelByKey(Int_t key, Int_t defkey);
    bool SetDecayModel(Int_t didx,      PChannelModel *model);
    bool SetDecayModelByKey(Int_t didx, PChannelModel *model);
    Double_t GetDecaySCFactor(Int_t didx);
    void SetDecaySCFactor(Int_t didx, Double_t factor);
    bool CheckSCAbort(Int_t didx);  //to stop endless loops
    double GetDecayBR(int , double); 
    // branching ratio by mode index & mass (GeV/c^2) 
    
    void ListDecayBR(const Char_t *pid, double mass) { 
	ListDecayBR(makeStaticData()->IsParticleValid(pid), mass); 
    } 
    void ListDecayBR(int pid, double mass); 
    // list branching ratios by particle id & mass (GeV/c^2) 
  
    int PickDecayChannel(const int &, const double &);
    // decay index for particle pid of given mass (GeV/c**2),
    // randomly selected consistent with the branching ratios

    int PickDecayChannel(const char *id, const double &m) {
	// as above, by particle name
	return PickDecayChannel(makeStaticData()->IsParticleValid(id), m); 
    }

    int PickDecayChannel(const int &, const double &, int *);
    // number and pids of decay products for the decay of particle 
    // pid of given mass(GeV/c**2), via a randomly selected mode 
    
    int PickDecayChannel(const char *id, const double &m, int *array) {
	// as above, by particle name
	return PickDecayChannel(makeStaticData()->IsParticleValid(id), m, array);
    }
    
    //**** Particles
    PChannelModel *GetParticleModel(Int_t pid);
    PChannelModel *GetParticleSecondaryModel(const char *name, const char *modelname);

    Double_t GetParticleTotalWidth(Double_t mass, Int_t pid);
    // mass-dependent total resonance decay width by id (units GeV/c**2)

    Double_t GetParticleTotalWidthSum(Double_t mass, Int_t id, Int_t flag=0);
    // same as above but by resumming the partial width (slower but more precise)
    // flag=1: take into account only hadronic decays

    Double_t GetParticleTotalWeight(Double_t mass, Int_t pid, Int_t didx=-1);
    Double_t GetParticleScalingFactor(Int_t didx);
    void SetParticleScalingFactor(Int_t didx, Double_t factor);

    int GetParticleDepth(const int &id, int flag=0);
    
    int GetParticleDepth(const char *id, int i=0) { 
	return GetParticleDepth(makeStaticData()->IsParticleValid(id), i);
    }
      
    double GetParticleLife(const int &id, double m=0, int idx=-1);
    // mean life
    // Arguments: 1. id=particle id 
    //            2. m=mass (GeV/c**2)
    //            3. idx=decay-mode index
    
    double GetParticleLife(const char *id, double m=0, int idx=-1) {
	// as above, by particle name
	return GetParticleLife(makeStaticData()->IsParticleValid(id), m, idx);
    }

    //Debug info... similar to PStaticData
    void PrintParticle(int pid);
    void PrintParticleByKey(int key);
    void PrintDecayByKey(int key);

    PParticle * GetBatchParticle(const char *name, Int_t make_val=1);
    TH1   *GetBatchHistogram(const char *name);
    Bool_t SetBatchHistogram(const char *name, TH1 *histo);

    void PushPChannel(TObject *obj) {
        if (num_pchannels == MAX_PCHANNEL_OBJECTS) {
            Warning("Push", "MAX_PCHANNEL_OBJECTS reached");
            return;
        }
        pchannel_list[num_pchannels++]=obj;
    };

    TObject **GetPChannels(Int_t *num) {
        *num = num_pchannels;
        if (num_pchannels) return pchannel_list;
        return NULL;
    };

    void DumpPChannels(void) {
        for (int i=0; i<num_pchannels; i++)
            pchannel_list[i]->Print();
    };


 private:
     Int_t *i_result;
     char  *c_result;
     Double_t *d_result;
     TObject *t_result;
     Int_t  pid_param,  enhance_br_param;
     Int_t  name_param, model_param, didx_param, scfactor_param, sccount_param;
     Int_t  pnmodes_param, link_param;

     TObject *pchannel_list[MAX_PCHANNEL_OBJECTS]; //list of all created PChannels for bookkeeping
     Int_t num_pchannels;

  ClassDef(PDynamicData, 0) //Pluto Dynamic Data Interface (for mass-dependent values)
};

#endif // _PDATAUTIL_H_