//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMBTree Emcl class                                                   //
//  E. Nagy and E. Thomas                                                           //
//  Revised by E. Nagy October 30th 2003                                //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "tmb_tree/TMBEmcl.hpp"


ClassImp(TMBEmcl)

 TMBEmcl::TMBEmcl(Float_t E, Float_t pT, Float_t eta, Float_t phi,
             Float_t* pxyz, Float_t q,
             Int_t id, Float_t iso, Float_t EisoCore, Int_t isol,
             Int_t nb_CPS, Int_t nb_FPS,
             Float_t* floorE, Float_t* floorX, Float_t* floorY, Float_t* floorZ, 
             Float_t* flrS1, Float_t* flrS2, Float_t* flrC, Int_t* flrNch,
             Float_t EMfrac, Float_t HA, Float_t HMx7, Float_t HMx8, Float_t HMx41,
             Float_t elk8, Float_t elk41, Float_t Excess, 
             Float_t* rRC, Float_t* rR1, Float_t* rR2, 
             const char *algoname,
             TRef chptr, TRef vtxref, 
	     TRefArray* cpsptr, TRefArray* fpsptr, TRefArray* ecells)
{

Set(E, pT, eta, phi, pxyz, q, id, iso, EisoCore, isol,
   nb_CPS, nb_FPS, floorE, floorX, floorY, floorZ,
   flrS1, flrS2, flrC, flrNch,
   EMfrac, HA, HMx7, HMx8, HMx41, elk8, elk41,
   Excess, rRC, rR1, rR2, algoname, 
   chptr, vtxref, cpsptr, fpsptr, ecells);

}
 void TMBEmcl::Set(Float_t E, Float_t pT, Float_t eta, Float_t phi,
		  Float_t* pxyz, Float_t q,
		  Int_t id, Float_t iso, Float_t EisoCore, Int_t isol,
		  Int_t nb_CPS, Int_t nb_FPS,
		  Float_t* floorE, Float_t* floorX, Float_t* floorY, Float_t* floorZ, 
		  Float_t* flrS1, Float_t* flrS2, Float_t* flrC, Int_t* flrNch,
		  Float_t EMfrac, Float_t HA, Float_t HMx7, Float_t HMx8, Float_t HMx41,
		  Float_t elk8, Float_t elk41, Float_t Excess, 
		  Float_t* rRC, Float_t* rR1, Float_t* rR2, 
		  const char *algoname,
		  TRef chptr, TRef vtxref, 
		  TRefArray* cpsptr, TRefArray* fpsptr, TRefArray* ecells)
{

             _E         = E;
             _pT        = pT;
             _eta       = eta;
             _phi       = phi;

        for (Int_t j=0; j<3; j++)
             _pxyz[j]   = *(pxyz++);

             _q         = q;
             _id        = id;
             _iso       = iso;
             _EisoCore  = EisoCore;
             _isol      = isol;
             _nb_CPS    = nb_CPS;
             _nb_FPS    = nb_FPS;

        for (Int_t j=0; j<6; j++){
             _floorE[j] = *(floorE++);
             _flrNch[j] = *(flrNch++);
             _floorX[j] = *(floorX++);
             _floorY[j] = *(floorY++);
             _floorZ[j] = *(floorZ++);
             _flrS1[j]  = *(flrS1++);
             _flrS2[j]  = *(flrS2++);
             _flrC[j]   = *(flrC++);
        }

             _EMfrac    = EMfrac;                           
             _HA        = HA;
             _HMx7      = HMx7;
             _HMx8      = HMx8;
             _HMx41     = HMx41;
             _elk8      = elk8;
             _elk41     = elk41;
             _Excess    = Excess;

             _algoname  = algoname;

        for (Int_t j=0; j<5; j++){
             _rRC[j]    = *(rRC++);
             _rR1[j]    = *(rR1++);
             _rR2[j]    = *(rR2++);
        }
             _chptr     = chptr;
             _vtxref    = vtxref;

      _cpsptr.Clear();
       if (cpsptr) {
         for (int i=0; i<cpsptr->GetLast()+1; i++) {
           _cpsptr.Add( cpsptr->At(i) );
         }
       }
       _fpsptr.Clear();
       if (fpsptr) {
         for (int i=0; i<fpsptr->GetLast()+1; i++) {
           _fpsptr.Add( fpsptr->At(i) );
         }
       }
       _ecells.Clear();
       if (ecells) {
         for (int i=0; i<ecells->GetLast()+1; i++) {
           _ecells.Add( ecells->At(i) );
         }
       }
}

 void TMBEmcl::Set1(Bool_t is_in_fiducial, Bool_t is_in_phi_fiducial,
		   Bool_t is_in_eta_fiducial, Float_t Calpx,
		   Float_t Calpy, Float_t Calpz, Float_t Calpt, Float_t CalE,
		   Float_t CalPhi, Float_t CalEta, Float_t CalDetectorPhi,
		   Float_t CalDetectorEta, Float_t sigE, TRef CpsBest,
		   Float_t CpsFitZVtx, Float_t CpsFitZVtxErr,
		   Float_t CpsFitDCA, Float_t CpsFitDCAErr,
		   Float_t CpsChi2Match, Float_t LhoodIso8,
		   Float_t Lhood8, Bool_t has_track_match, Float_t TrMatchChi2ProbBest,
		   Float_t SpatialTrMatchChi2ProbBest, TRef chptrBest,
		   Int_t nChPart, TRefArray* ChPart, 
		   TArrayF* TrMatchChi2Prob, TArrayF* SpatialTrMatchChi2Prob,
		   TArrayF* CPSFitChi2Match, 
		   TArrayF* CPSFitZVtx, TArrayF* CPSFitZVtxErr, TArrayF* CPSFitDCA, TArrayF *CPSFitDCAErr)
{
  _is_in_fiducial =  is_in_fiducial;
  _is_in_phi_fiducial =  is_in_phi_fiducial;
  _is_in_eta_fiducial =  is_in_eta_fiducial;
  _Calpx =  Calpx;
  _Calpy =  Calpy;
  _Calpz =  Calpz;
  _Calpt =  Calpt;
  _CalE =  CalE;
  _CalPhi =  CalPhi;
  _CalEta =  CalEta;
  _CalDetectorPhi =  CalDetectorPhi;
  _CalDetectorEta =  CalDetectorEta;
  _sigE =  sigE;
  _CpsBest =  CpsBest;
  _CpsFitZVtx =  CpsFitZVtx;
  _CpsFitZVtxErr =  CpsFitZVtxErr;
  _CpsFitDCA =  CpsFitDCA;
  _CpsFitDCAErr =  CpsFitDCAErr;
  _CpsChi2Match =  CpsChi2Match;
  _LhoodIso8 =  LhoodIso8;
  _Lhood8 =  Lhood8; 
  _has_track_match =  has_track_match;
  _TrMatchChi2ProbBest =  TrMatchChi2ProbBest;
  _SpatialTrMatchChi2ProbBest =  SpatialTrMatchChi2ProbBest;
  _chptrBest =  chptrBest;
  _nChPart =  nChPart;
  
  _ChPart.Clear();
  if (ChPart) {
    for (Int_t i=0; i< ChPart->GetLast()+1; i++) {
      _ChPart.Add(ChPart->At(i) );
    }
  }
  if (TrMatchChi2Prob) _TrMatchChi2Prob = *TrMatchChi2Prob;
  if (SpatialTrMatchChi2Prob) _SpatialTrMatchChi2Prob = *SpatialTrMatchChi2Prob;

  if (CPSFitChi2Match) _CPSFitChi2Match = *CPSFitChi2Match;
  if (CPSFitZVtx) _CPSFitZVtx = *CPSFitZVtx;
  if (CPSFitZVtxErr) _CPSFitZVtxErr = *CPSFitZVtxErr;
  if (CPSFitDCA) _CPSFitDCA = *CPSFitDCA;
  if (CPSFitDCAErr) _CPSFitDCAErr = *CPSFitDCAErr;
  
}

 void TMBEmcl::Set2(Float_t bestPSz, TArrayF* PSz, Int_t has_cps_match, 
		   TArrayI* cps_match, 
		   Float_t bestcps_match_chi2, TArrayF* cps_match_chi2, 
		   Int_t nEMLikeCPSClusters, Float_t* diphoton_p4v) {
  _bestPSz = bestPSz;
  if (PSz) _PSz = *PSz;
  _has_cps_match = has_cps_match;
  if (cps_match) _cps_match = *cps_match;
  _bestcps_match_chi2 = bestcps_match_chi2;
  if (cps_match_chi2) _cps_match_chi2 = *cps_match_chi2;
  _nEMLikeCPSClusters = nEMLikeCPSClusters;
  for (int i=0; i < 4; ++i ) 
    _diphoton_p4v[i] = diphoton_p4v[i];
}