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

#include "Fragment.h"
#include "TMath.h"
#include "Riostream.h"

ClassImp(Fragment)
////////////////////////////////////////////////////////////////////////////////
//
// Classe contenant les informations relatives a un fragment
//
////////////////////////////////////////////////////////////////////////////////

Int_t	Fragment::nb=0;
Int_t	Fragment::nb_crea=0;
Int_t	Fragment::nb_dest=0;
Double_t	Fragment::mnuc=931.5;

//============================================================================
// Methodes de base
//============================================================================
//_____________________________________________________________________________
 void Fragment::initFragment(void)
	{
//
// Initialisation des champs de Fragment
// Cette methode privee n'est appelee que par les constructeurs
//
        if(!this->IsOnHeap()) nb++;
	Z=0;
	A=0;
	v.SetXYZ(0.,0.,1.);

	nb_crea++;
	}

//_____________________________________________________________________________
 Fragment::Fragment(void):TObject()
	{
//
// Createur par default
//
	initFragment();
	}
	
//_____________________________________________________________________________
 Fragment::~Fragment(void)
       {
// 
// Destructeur
//
        nb--;
	nb_dest++;
       }
//============================================================================
// Acces directs aux champs
//============================================================================
//_____________________________________________________________________________
 void Fragment::Set(Int_t aa, Int_t zz, TVector3 vit)
	{
//
// Methode d'attribution de valeur des champs
//
	A=aa;
	Z=zz;
	v=vit;
	}

//_____________________________________________________________________________
 void Fragment::SetA(Int_t aa)
	{
//
// Methode d'attribution de A
//
	A=aa;
	}

//_____________________________________________________________________________
 void Fragment::SetZ(Int_t zz)
	{
//
// Methode d'attribution de Z
//
	Z=zz;
	}

//_____________________________________________________________________________
 void Fragment::SetVit(TVector3 vit)
	{
//
// Methode d'attribution de la vitesse. Les coordonnées doivent etre en cm/ns.
//
	v=vit;
	}

//_____________________________________________________________________________
 void Fragment::SetVit(Double_t vx, Double_t vy, Double_t vz)
	{
//
// Methode d'attribution de la vitesse. Les coordonnées doivent etre en cm/ns.
//
	v.SetXYZ(vx,vy,vz);
	}

//_____________________________________________________________________________
 Int_t Fragment::GetA(void)
	{
//
// Retourne le nombre de nucleons (nombre de masses)
//
	return A;
	}

//_____________________________________________________________________________
 Int_t Fragment::GetZ(void)
	{
//
// Retourne la charge
//
	return Z;
	}

//_____________________________________________________________________________
 TVector3 Fragment::GetVit(void)
	{
//
// Retourne la vitesse. Les coordonnees sont en cm/ns
//	
	return v;
	}

//============================================================================
// Acces calcules aux champs
//============================================================================
//_____________________________________________________________________________
 void Fragment::SetEnergie(Double_t e)
	{
//
// Attribution de l'energie cinetique en MeV
//	
	if(A > 0)
	 {
	 Double_t vitesse=TMath::Sqrt(2.*e/GetMasse())*30.;
	 if(v.Mag()==0) v.SetXYZ(0.,0.,1.);
	 v.SetMag(vitesse);
	 }
	else
	 {
	 cerr << "Attribuer le nombre de nucleons avant l'energie..." << endl;
	 }
	}

//_____________________________________________________________________________
 void Fragment::SetTheta(Double_t theta)
	{
//
// Attribution de l'angle polaire Theta en degres
//	
	Double_t the=theta*TMath::Pi()/180.;
	v.SetTheta(the);
	}

//_____________________________________________________________________________
 void Fragment::SetPhi(Double_t phi)
	{
//
// Attribution de l'angle Phi en degres
//	
	Double_t p=phi*TMath::Pi()/180.;
	v.SetPhi(p);
	}

//_____________________________________________________________________________
 Double_t  Fragment::GetMasse(void)
	{
//
// Retourne la masse en MeV/c2
//	
	return A*mnuc;
	}

//_____________________________________________________________________________
 Double_t  Fragment::GetTheta(void)
	{
//
// Retourne l'angle polaire Theta en degres
//	
	return v.Theta()*180./TMath::Pi();
	}

//_____________________________________________________________________________
 Double_t  Fragment::GetPhi(void)
	{
//
// Retourne l'angle Phi en degres
//	
	return v.Phi()*180./TMath::Pi();
	}

//_____________________________________________________________________________
 Double_t Fragment::GetEcin(void)
	{
// 
// Retourne l'energie cinetique en MeV
//
	return GetMasse()*v.Mag2()/1800.;
	}

//_____________________________________________________________________________
 Double_t Fragment::GetEperp(void)
	{
//
// Retourne l'energie cinetique perpendiculaire en MeV.
//
	return GetMasse()*v.Perp2()/1800.;
	}

//_____________________________________________________________________________
 Double_t Fragment::GetRayon(void)
	{
//
// Retourne le rayon theorique (1.2*A^(1./3.)) en fm. 
//
	return 1.2*TMath::Power((Double_t)A,1./.3);
	}

//_____________________________________________________________________________
 Double_t Fragment::GetEgoutliq(void)
	{
//
// Calcul de l'energie du fondamental "Goutte Liquide" en MeV.
//
	Double_t av=16.;
	Double_t as=18.;
	Double_t ac=0.72;
	Double_t aa=23.5;
	
	return av*A
	       -as*TMath::Power((Double_t)A,2./.3)
	       -ac*Z*(Z-1.)/TMath::Power((Double_t)A,1./3.)
	       -aa*TMath::Power(A-2*Z,2)/(Double_t)A;
	}	

//_____________________________________________________________________________
 void Fragment::Print(Option_t* option) const
	{
//
// Affichage
//
	Char_t mes[80];
	sprintf(mes,"%3d, %2d : %8.2f %8.2f %8.2f",A,Z,v.X(),v.Y(),v.Z());
	cout << mes << endl;
	}