//
// D.Cussol 
//
// 21/10/2002:
// Creation d'une classe relative aux Events INDRA 
// Formation ROOT
//

#include "Event.h"
#include "TMath.h"
#include "Riostream.h"

ClassImp(Event)
////////////////////////////////////////////////////////////////////////////////
//
// Classe contenant les informations relatives a un evenement
//
////////////////////////////////////////////////////////////////////////////////

Int_t	Event::nb=0;
Int_t	Event::nb_crea=0;
Int_t	Event::nb_dest=0;
TClonesArray *Event::sfrags=0;

//============================================================================
// Methodes de base
//============================================================================
//_____________________________________________________________________________
 void Event::initEvent(void)
	{
//
// Initialisation des champs de Event
// Cette methode privee n'est appelee que par les constructeurs
//
        nb++;
	mult=0;
	if(!sfrags) 
	 {
	 sfrags=new TClonesArray("Fragment",100);
	 for(Int_t i=0;i<100;i++)
	 	Fragment *tmp = new((*sfrags)[i]) Fragment();

	 }
	frags=sfrags;
	nb_crea++;
	}

//_____________________________________________________________________________
 Event::Event(void):TNamed()
	{
//
// Createur par default
//
	Char_t	*nom=new Char_t[80];

	initEvent();
	sprintf(nom,"Event_%d",nb);
	SetName(nom);
	SetTitle(nom);

	delete [] nom;
	}
	
//_____________________________________________________________________________
 Event::Event(Char_t *nom)
	{
//
// Constructeur avec un nom
//
	initEvent();
	SetName(nom);
	SetTitle(nom);
	}

//_____________________________________________________________________________
 Event::~Event(void)
       {
// 
// Destructeur
//
        nb--;
	if(nb==0) 
	 {
	 delete sfrags;
	 }
	nb_dest++;
       }
//============================================================================
// Acces directs aux champs
//============================================================================
//_____________________________________________________________________________
 void Event::AddFragment(Fragment *f)
	{
//
// Ajout d'un fragment a l'evenement
//
	TClonesArray &ltca=*frags;
	Fragment *tmp=(Fragment *)ltca[mult];
	if(tmp)
	 {
	 tmp->Set(f->GetA(),f->GetZ(),f->GetVit());
	 mult++;
	 }
	}

//_____________________________________________________________________________
 void Event::Reset(void)
	{
//
// Remise a zero de l'evenement, vide la liste des fragments
//
	if(frags) frags->Clear();
	mult=0;
	}

//_____________________________________________________________________________
 Int_t Event::GetMult(void)
	{
//
// Nombre de particules
//
	return mult;
	}

//_____________________________________________________________________________
 Fragment *Event::GetFragment(Int_t i)
	{
//
// Retourne le pointeur sur le i eme fragment de l'evenement
// ATTENTION: l'indice i varie de 1 au nombre total de particules.
//
// Exemple d'utilisation (evt est un pointeur sur un objet de type Event):
//
// Fragment *fra=evt->GetFragment(3); ! retourne le pointeur sur le 3eme fragment
//
	Fragment *f=0;
	if(frags)
	 if(i > 0 && i <= mult) 
	  {
	  f=(Fragment *)frags->At(i-1);
	  }
	 else
	  {
	  cerr << "L'indice i doit etre comprit entre 1 et " << mult << "." <<
	  endl;
	  }
	else
	 {
	 cerr << "Le TClonesArray est null..." << endl;
	 }
	return f;
	}
	
//============================================================================
// Acces calcules aux champs
//============================================================================
//_____________________________________________________________________________
 Int_t Event::GetZtot(void)
	{
//
// Somme des charges de tous les fragments de l'evenement
//
	Fragment *f;
	Int_t Z=0;
	if(frags)
	 for(Int_t i=0;i<mult;i++)
	  {
	  f=(Fragment *)frags->At(i);
	  Z+=f->GetZ();
	  }
	return Z;
	}

//_____________________________________________________________________________
 TVector3 Event::GetPtot(void)
	{
//
// Somme des produits Charge*(module de la vitesse) pour tous les fragments de
// l'evenement
//	
	Fragment *f;
	TVector3 pt(0.,0.,0.);
	for(Int_t i=0;i<mult;i++)
	 {
	 f=(Fragment *)frags->At(i);
	 pt+=(f->GetZ())*(f->GetVit());
	 }
	return pt;
	}

//_____________________________________________________________________________
 Double_t Event::GetEcin(void)
	{
// 
// Somme des energies cinetiques pour tous les fragments de l'evenement
//
	Fragment *f;
	Double_t ect=0;
	if(frags)
	 for(Int_t i=0;i<mult;i++)
	  {
	  f=(Fragment *)frags->At(i);
	  ect+=f->GetEcin();
	  }
	return ect;
	}

//_____________________________________________________________________________
 Double_t Event::GetEperp(void)
	{
//
// Somme des energies cinetiques perpendiculaires au faisceau  pour tous les 
// fragments de l'evenement
//
	Fragment *f;
	Double_t ept=0;
	if(frags)
	 for(Int_t i=0;i<mult;i++)
	  {
	  f=(Fragment *)frags->At(i);
	  ept+=f->GetEperp();
	  }
	return ept;
	}

//_____________________________________________________________________________
 void Event::Print(Option_t* option) const
	{
//
// Affichage de l'evenement
//
	cout << "=====================================================" << endl;
	cout << "Mult : " << mult << endl;
	if(frags)
	 for(Int_t i=0;i<mult;i++)
	  {
	  cout << i+1 << " -> ";
	  ((Fragment *)frags->At(i))->Print();
	  }
	cout << endl;
	}