source: Sophya/trunk/SophyaPI/PIext/nomhistadapter.cc@ 463

#include "machdefs.h"
#include <stdlib.h>
#include <typeinfo>
#include <iostream.h>
#include <string>

#include "nomhistadapter.h"
#include "pihisto.h"
#include "pihisto2d.h"
#include "pipodrw.h"

//-------------------------------------------------------------------------
// Class Adaptateur d'objet (Pour NamedObjMgr) d'objet Histo / HProf
//-------------------------------------------------------------------------

/* --Methode-- */
NOMAdapter_Histo::NOMAdapter_Histo(Histo* o)
  : NObjMgrAdapter(o)
{
mHis = o;
}

/* --Methode-- */
NOMAdapter_Histo::~NOMAdapter_Histo()
{
}

/* --Methode-- */
NObjMgrAdapter* NOMAdapter_Histo::Clone(AnyDataObj* o)
{
Histo* h = dynamic_cast<Histo *>(o);
if (h) return ( new NOMAdapter_Histo(h) );
return ( new NObjMgrAdapter(o) );
}

/* --Methode-- */
AnyDataObj* NOMAdapter_Histo::GetCopyObj()
{
HProf * hp = dynamic_cast<HProf *>(mHis);
if (hp == NULL)   return( new Histo(*mHis) );
else return( new HProf(*hp) );
}

/* --Methode-- */
void NOMAdapter_Histo::SavePPF(POutPersist& pos, string const & nom)
{
#ifdef SANS_EVOLPLANCK
// PEIDA-EROS L'histo est lui-meme PPersist
string tag = nom;  // A cause de const
mHis->Write(pos,0,tag);
#else
string s = typeid(*mObj).name();
cout << "NOMAdapter_Histo::SavePPF() - Error : Not supported for " << s << endl;
#endif
}

/* --Methode-- */
void NOMAdapter_Histo::Print(ostream& os)
{
mHis->Print(60);
}

/* --Methode-- */
PIDrawer* NOMAdapter_Histo::GetDrawer(string & dopt)
{
if (typeid(*mHis) == typeid(HProf))  dopt = "fcirclemarker5," + dopt;
else dopt = "thinline," + dopt;
return( new PIHisto(mHis, false) );
}

/* --Methode-- */
NTupleInterface* NOMAdapter_Histo::GetNTupleInterface(bool& adel)
{
adel = true;
return( new NTupInt_Histo(mHis) );
}


// -------------------------------------------------------------

/* --Methode-- */
NTupInt_Histo::NTupInt_Histo(Histo* h)
{
mHis = h;
}

/* --Methode-- */
NTupInt_Histo::~NTupInt_Histo()
{
}

/* --Methode-- */
uint_4 NTupInt_Histo::NbLines() const 
{
return(mHis->NBins());
}

/* --Methode-- */
uint_4 NTupInt_Histo::NbColumns() const
{
return(4);
}

/* --Methode-- */
r_8* NTupInt_Histo::GetLineD(int k) const
{
int i;
if ((k < 0) || (k >= mHis->NBins())) 
    for(i=0; i<4; i++)  mRet[i] = 0.;
else { 
  mRet[0] = k;  mRet[1] = mHis->BinCenter(k);
  mRet[2] = (*mHis)(k); mRet[3] = mHis->Error(k); 
  }
return(mRet);
}

/* --Methode-- */
string NTupInt_Histo::VarList_C(const char* nx) const
{
string nomx;
if (nx) nomx = nx;
else nomx = "_xh_";
string vardec = "double i,x,val,err; \n";
vardec += "i = " + nomx + "[0];  x = " + nomx + "[1]; \n";
vardec += "val = " + nomx + "[2];  err = " + nomx + "[3]; \n";
return(vardec);
}

//-------------------------------------------------------------------------
// Class Adaptateur d'objet (Pour NamedObjMgr) d'objet Histo2D
//-------------------------------------------------------------------------


/* --Methode-- */
NOMAdapter_Histo2D::NOMAdapter_Histo2D(Histo2D* o)
  : NObjMgrAdapter(o)
{
mHis = o;
}

/* --Methode-- */
NOMAdapter_Histo2D::~NOMAdapter_Histo2D()
{
}

/* --Methode-- */
NObjMgrAdapter* NOMAdapter_Histo2D::Clone(AnyDataObj* o)
{
Histo2D* h = dynamic_cast<Histo2D *>(o);
if (h) return ( new NOMAdapter_Histo2D(h) );
return ( new NObjMgrAdapter(o) );
}

/* --Methode-- */
AnyDataObj* NOMAdapter_Histo2D::GetCopyObj()
{
return ( new Histo2D(*mHis) );
}

/* --Methode-- */
void NOMAdapter_Histo2D::SavePPF(POutPersist& pos, string const & nom)
{
#ifdef SANS_EVOLPLANCK
// PEIDA-EROS L'histo est lui-meme PPersist
string tag = nom;  // A cause de const
mHis->Write(pos,0,tag);
#else
string s = typeid(*mObj).name();
cout << "NOMAdapter_Histo2D::SavePPF() - Error : Not supported for " << s << endl;
#endif
}

/* --Methode-- */
void NOMAdapter_Histo2D::Print(ostream& os)
{
mHis->Print();
}

/* --Methode-- */
PIDrawer* NOMAdapter_Histo2D::GetDrawer(string & dopt)
{
dopt = "thinline," + dopt;
return( new PIHisto2D(mHis, false) );
}

/* --Methode-- */
P2DArrayAdapter* NOMAdapter_Histo2D::Get2DArray(string & dopt)
{
return (new POH2DAdapter(mHis, false) );
}

/* --Methode-- */
NTupleInterface* NOMAdapter_Histo2D::GetNTupleInterface(bool& adel)
{
adel = true;
return( new NTupInt_Histo2D(mHis) );
}



// -------------------------------------------------------------

/* --Methode-- */
NTupInt_Histo2D::NTupInt_Histo2D(Histo2D* h)
{
mHis = h;
}

/* --Methode-- */
NTupInt_Histo2D::~NTupInt_Histo2D()
{
}

/* --Methode-- */
uint_4 NTupInt_Histo2D::NbLines() const 
{
return(mHis->NBinX()*mHis->NBinY());
}

/* --Methode-- */
uint_4 NTupInt_Histo2D::NbColumns() const 
{
return(6);
}

/* --Methode-- */
r_8* NTupInt_Histo2D::GetLineD(int n) const
{
int i,j;
float f2,f3;
if ((n < 0) || (n >= mHis->NBinX()*mHis->NBinY())) 
    for(i=0; i<6; i++)  mRet[i] = 0.;
else { 
  i = n%mHis->NBinX();  j = n/mHis->NBinX(); 
  mRet[0] = i;  mRet[1] = j;
  mHis->BinCenter(i,j,f2,f3);
  mRet[2] = f2;  mRet[3] = f3;  
  mRet[4] =  (*mHis)(i,j);  mRet[5] = mHis->Error(i, j);
  }
return(mRet);
}

/* --Methode-- */
string NTupInt_Histo2D::VarList_C(const char* nx) const
{
string nomx;
if (nx) nomx = nx;
else nomx = "_xh_";
string vardec = "double i,j,x,y,val,err; \n";
vardec += "i = " + nomx + "[0];  j = " + nomx + "[1]; \n";
vardec += "x = " + nomx + "[2];  y = " + nomx + "[3]; \n";
vardec += "val = " + nomx + "[4];  err = " + nomx + "[5]; \n";
return(vardec);
}



//-------------------------------------------------------------------------
// Class Adaptateur d'objet (Pour NamedObjMgr) d'objet NTuple
//-------------------------------------------------------------------------

/* --Methode-- */
NOMAdapter_NTuple::NOMAdapter_NTuple(NTuple* o)
  : NObjMgrAdapter(o)
{
mNt = o;
}

/* --Methode-- */
NOMAdapter_NTuple::~NOMAdapter_NTuple()
{
}

/* --Methode-- */
NObjMgrAdapter* NOMAdapter_NTuple::Clone(AnyDataObj* o)
{
NTuple* nt = dynamic_cast<NTuple *>(o);
if (nt) return ( new NOMAdapter_NTuple(nt) );
return ( new NObjMgrAdapter(o) );
}

/* --Methode-- */
AnyDataObj* NOMAdapter_NTuple::GetCopyObj()
{
return ( new NTuple(*mNt) );
}

/* --Methode-- */
void NOMAdapter_NTuple::SavePPF(POutPersist& pos, string const & nom)
{
#ifdef SANS_EVOLPLANCK
// PEIDA-EROS L'histo est lui-meme PPersist
string tag = nom;  // A cause de const
mNt->Write(pos,0,tag);
#else
string s = typeid(*mObj).name();
cout << "NOMAdapter_NTuple::SavePPF() - Error : Not supported for " << s << endl;
#endif
}

/* --Methode-- */
void NOMAdapter_NTuple::Print(ostream& os)
{
os << mNt->Info();
os << *(mNt);
}


/* --Methode-- */
NTupleInterface* NOMAdapter_NTuple::GetNTupleInterface(bool& adel)
{
adel = false;
return(mNt);
// return( new NTupInt_NTuple(mNt) );
}

//-------------------------------------------------------------------------
// Class Adaptateur d'objet (Pour NamedObjMgr) d'objet XNTuple
//-------------------------------------------------------------------------

/* --Methode-- */
NOMAdapter_XNTuple::NOMAdapter_XNTuple(XNTuple* o)
  : NObjMgrAdapter(o)
{
mNt = o;
}

/* --Methode-- */
NOMAdapter_XNTuple::~NOMAdapter_XNTuple()
{
}

/* --Methode-- */
NObjMgrAdapter* NOMAdapter_XNTuple::Clone(AnyDataObj* o)
{
XNTuple* nt = dynamic_cast<XNTuple *>(o);
if (nt) return ( new NOMAdapter_XNTuple(nt) );
return ( new NObjMgrAdapter(o) );
}


/* --Methode-- */
void NOMAdapter_XNTuple::SavePPF(POutPersist& pos, string const & nom)
{
#ifdef SANS_EVOLPLANCK
// PEIDA-EROS L'histo est lui-meme PPersist
string tag = nom;  // A cause de const
mNt->Write(pos,0,tag);
#else
string s = typeid(*mObj).name();
cout << "NOMAdapter_XNTuple::SavePPF() - Error : Not supported for " << s << endl;
#endif
}

/* --Methode-- */
void NOMAdapter_XNTuple::Print(ostream& os)
{
// os << mNt->Info();
mNt->Show(os);
}


/* --Methode-- */
NTupleInterface* NOMAdapter_XNTuple::GetNTupleInterface(bool& adel)
{
adel = false;
return(mNt);
}