EmcCluster.h

Go to the documentation of this file.

#ifndef EMCCLUSTER_H
#define EMCCLUSTER_H

// Name: EmcCluster.h
// Author: A. Bazilevsky (RIKEN-BNL)
// Major modifications by M. Volkov (RRC KI) Jan 27 2000

// Standard includes
#include <cstdio>
#include <cmath>
#include <vector>
#include "TObject.h"
#include "TMath.h"

// Forward declarations
class EmcSectorRec;
class EmcCluster;
class EmcPeakarea;
class EmcEmshower;

struct EmcModule
{
  EmcModule();
  EmcModule(int ich_, int softkey_, float amp_, float tof_,
            int deadmap_, int warnmap_, float adc_, float tac_);

  int ich;   // module id (linear)
  int softKey; /* software key = arm/sector/row/column =
                  100000 * iarm +
                  10000 * iS +
                  100 * iy +
                  iz                       */
  float amp; // module signal
  float tof; // module time-of-flight
  int deadmap; // module dead map: see emcCalibratedDataObject.h
  int warnmap; // MV 2001/12/06
  float adc; // ADC amplitude
  float tac; // TAC amplitude
};

// ///////////////////////////////////////////////////////////////////////////

class EmcCluster : public TObject
{

public:

  EmcCluster()
  {}

  EmcCluster(EmcSectorRec *sector): fOwner(sector)
  {}

#ifndef __CINT__

  EmcCluster(const std::vector<EmcModule>& hlist,
             EmcSectorRec *sector)
    : fOwner(sector)
  {
    fHitList = hlist;
  }
#endif

  virtual ~EmcCluster()
  {}

#ifndef __CINT__

  void ReInitialize( const std::vector<EmcModule>& hlist )
  {
    fHitList = hlist;
  }
#endif

  int GetNofHits()
  {
    return fHitList.size();
  }
  void GetHits(EmcModule* phit, int n);
#ifndef __CINT__

  void GetHitList(std::vector<EmcModule> *&plist)
  {
    plist = &fHitList;
  };
#endif

  EmcModule GetMaxTower();
  EmcModule GetImpactTower();
  float GetTowerEnergy( int ich );
  float GetTowerEnergy( int ix, int iy );
  float GetTowerToF( int ich );
  int GetTowerDeadMap( int ich );
  int GetTowerWarnMap( int ich ); // MV 2002/02/18 bugfix
  float GetTowerADC( int ich ); // MV 2002/03/12 bugfix
  float GetTowerTAC( int ich ); // MV 2002/03/12 bugfix
  int GetNDead();
  int GetDeadMap(); // MV 2001/12/06
  int GetWarnMap(); // MV 2001/12/06
  float GetE4();
  float GetE9();
  float GetE9( int ich );
  float GetECore();
  float GetTotalEnergy();
  void GetMoments( float* pxcg, float* pycg,
                   float* pxx, float* pxy, float* pyy );
  void GetCorrPos( float* pxc, float* pyc );
  void GetGlobalPos( float* pxg, float* pyg, float* pzg );
  void GetErrors( float* pde, float* pdx, float* pdy, float* pdz);
  void GetChar( float* pe,
                float* pxcg, float* pysg,
                float* pxc, float* pyc,
                float* pxg, float* pyg, float* pzg,
                float* pxx, float* pxy, float* pyy,
                float* pde, float* pdx, float* pdy, float* pdz );
  int GetPeaks(EmcPeakarea*, EmcModule*);

protected:

#ifndef __CINT__

  std::vector<EmcModule> fHitList;
#endif

  EmcSectorRec *fOwner; // what sector it belongs to

  // static members
  static int const fgMaxNofPeaks;
  static int const fgPeakIter;
  static float const fgEmin;
  static float const fgChisq;
  static float const fgXABSURD;
  static float const fgYABSURD;

public:

  // MV 2002/02/28 moved these functions here from #define's

  static int max(int a, int b)
  {
    return a > b ? a : b;
  }
  static float max(float a, float b)
  {
    return a > b ? a : b;
  }
  static double max(double a, double b)
  {
    return a > b ? a : b;
  }

  static int min(int a, int b)
  {
    return a < b ? a : b;
  }
  static float min(float a, float b)
  {
    return a < b ? a : b;
  }
  static double min(double a, double b)
  {
    return a < b ? a : b;
  }

  static int ABS(int x)
  {
    return abs(x);
  }
  static float ABS(float x)
  {
    return fabsf(x);
  }
  static double ABS(double x)
  {
    return fabs(x);
  }

  static int lowint(float x)
  {
    return x < 0. ? int(x - 1) : int(x);
  }

};

// ///////////////////////////////////////////////////////////////////////////

class EmcPeakarea: public EmcCluster
{

public:

  EmcPeakarea(): fNdf(0), fCL(1.)
  {}

  EmcPeakarea(EmcSectorRec *sector):
    EmcCluster(sector), fNdf(0), fCL(1.)
  {}

#ifndef __CINT__

  EmcPeakarea(const std::vector<EmcModule>& hlist, EmcSectorRec *sector):
    EmcCluster(hlist, sector), fNdf(0), fCL(1.)
  {}
#endif

  virtual ~EmcPeakarea()
  {}

  float GetChi2();
  float GetChi2New();
  int GetNdf() const
  {
    return fNdf;
  } 
  // fetch number of degrees of freedom
  float GetCL() const
  {
    return fCL;
  } 
  // get CL (call only after GetChar())
  float GetCLNew();

  void GetCGmin( float* pxcgmin, float* pycgmin );

  void GetChar( float* pe, float* pec, float* pecore, float* pecorec,
                float* pxcg, float* pysg,
                float* pxcgmin, float* pysgmin,
                float* pxc, float* pyc,
                float* pxg, float* pyg, float* pzg,
                float* pxx, float* pxy, float* pyy,
                float* pchi,
                float* pde, float* pdx, float* pdy, float* pdz );

  int GetGammas( EmcEmshower* );

protected:

  int fNdf; // Number of degrees of freedom
  float fCL; // Confidence level

};

// ///////////////////////////////////////////////////////////////////////////

class EmcEmshower
{

public:

  EmcEmshower();
  EmcEmshower(EmcSectorRec *sector);

  EmcEmshower(float e, float x, float y, float chi, int ndf,
              EmcSectorRec *sector);

  void ReInitialize(float e, float x, float y, float chi, int ndf)
  {
    fEnergy = e;
    fXcg = x;
    fYcg = y;
    fChisq = chi;
    fNdf = ndf;
  }

  float GetTotalEnergy()
  {
    return fEnergy;
  }

  void GetCG(float* px, float* py)
  {
    *px = fXcg;
    *py = fYcg;
  }

  void GetCorrPos(float*, float* );

  void GetGlobalPos(float*, float*, float*);

    float GetChi2() const
      {
        return fChisq;
      }

  float GetCL() const
  {
    return fCL;
  } 
  // get CL (call only after GetChar())

  void GetErrors( float* pde, float* pdx, float* pdy, float* pdz);
  
  void GetChar( float* pe,
                float* pxcg, float* pysg,
                float* pxc, float* pyc,
                float* pxg, float* pyg, float* pzg,
                float* pchi,
                float* pde, float* pdx, float* pdy, float* pdz );
  
protected:

    EmcSectorRec* fOwner; // what sector it belongs to
    int fNdf; // Number of degrees of freedom
    float fCL; // Confidence level
    float fEnergy;
    float fXcg;
    float fYcg;
    float fChisq;

};

#endif // #ifdef EMCCLUSTER_H