/** CbmMuchSegmentation.h
 *@author Mikhail Ryzhinskiy <m.ryzhinskiy@gsi.de>
 *@since 20.06.07
 *@version 1.0
 **
 ** class for making parameter file for MUCH digitizer
 ** 
 **/


#ifndef CBMMUCHSEGMENTATION_H
#define CBMMUCHSEGMENTATION_H 1

#include <vector>
#include "TObject.h"
#include "TPave.h"
#include "TVector2.h"

class CbmMuchSegmentation : public TObject
{

 public:

  /** Default constructor **/
  CbmMuchSegmentation();

  /** Destructor **/
  virtual ~CbmMuchSegmentation();

  /** Runs segmentation procedure for each station/layer **/
  void SegmentMuch();

  /** Sets the name of the digitizer parameter file 
   *@param name  Name of the digitizer parameter file 
  **/
  void SetDigiFileName(char* name) { fDigiFileName = name; }


  /** Sets minimal resolution in X for the given layer 
   *@param iLayer  Number of a layer (1..fNLayers) 
   *@param sigmaX  Value of minimal resolution in X
  **/
  void SetMinSigmaX(Int_t iLayer, Double_t sigmaX);

  /** Sets minimal resolution in Y for the given layer 
   *@param iLayer  Number of a layer (1..fNLayers) 
   *@param sigmaY  Value of minimal resolution in Y
  **/
  void SetMinSigmaY(Int_t iLayer, Double_t sigmaY);

  /** Sets number of layers in the MUCH system (gaps between absorbers + 1) 
   *@param nLayers  Number of layers in MUCH 
  **/
  void SetNLayers(Int_t nLayers) { fNLayers = nLayers; }

  /** Sets angle between stations for the given layer 
   *@param iLayer  Number of a layer (1..fNLayers) 
  **/
  void SetAngle(Int_t iLayer, Double_t angle);

  /** Sets whether to create eps files for stations 
   *@param nSwitch  kTRUE, if eps files have to be created, kFALSE otherwise
  **/
  void SetCreateEps(Bool_t nSwitch) { fCreateEps = nSwitch; }




  /** Gets the name of the digitizer parameter file **/
  char* GetDigiFileName() { return fDigiFileName; }

  /** Gets minimal pad width for the given layer [cm] 
   *@param iLayer  Number of a layer (1..fNLayers) 
  **/
  Double_t GetMinPadWidth(Int_t iLayer) { return fMinPadWidth[iLayer-1]; }

  /** Gets minimal pad length for the given layer [cm] 
   *@param iLayer  Number of a layer (1..fNLayers) 
  **/
  Double_t GetMinPadLength(Int_t iLayer) { return fMinPadLength[iLayer-1]; }

  /** Gets minimal sector width for the given layer [cm] 
   *@param iLayer  Number of a layer (1..fNLayers) 
  **/
  Double_t GetMinSectorWidth(Int_t iLayer) { return fMinSectorWidth[iLayer-1]; }

  /** Gets minimal sector length for the given layer [cm] 
   *@param iLayer  Number of a layer (1..fNLayers) 
  **/
  Double_t GetMinSectorLength(Int_t iLayer) { return fMinSectorLength[iLayer-1]; }

  /** Gets minimal resolution in X for the given layer [microns] 
   *@param iLayer  Number of a layer (1..fNLayers) 
  **/
  Double_t GetMinSigmaX(Int_t iLayer) { return fMinSigmaX[iLayer-1]; }

  /** Gets minimal resolution in Y for the given layer [microns] 
   *@param iLayer  Number of a layer (1..fNLayers) 
  **/
  Double_t GetMinSigmaY(Int_t iLayer) { return fMinSigmaY[iLayer-1]; }

  /** Gets number of layers in the MUCH system (gaps between absorbers + 1) **/
  Int_t GetNLayers() { return fNLayers; }



 private:
  
  char*             fDigiFileName;     /** Name of the digitizer parameter file **/
  std::vector<Double_t>  fMinPadWidth;      /** Minimal pad width [cm] **/
  std::vector<Double_t>  fMinPadLength;     /** Minimal pad length [cm] **/
  std::vector<Double_t>  fMinSectorWidth;   /** Minimal sector width [cm] **/
  std::vector<Double_t>  fMinSectorLength;  /** Minimal sector length [cm] **/
  std::vector<Double_t>  fMinSigmaX;        /** Minimal resolution on X [microns] **/ 
  std::vector<Double_t>  fMinSigmaY;        /** Minimal resolution on Y [microns] **/
  std::vector<Double_t>  fAngle;            /** Angle between stations in each layer [degrees] **/
  std::vector<Int_t>     fNChannels;        /** Number of channels per sector **/
  std::vector<Int_t>     fNRegions;         /** Number of regions for each layer **/
  std::vector<std::vector<Double_t> > fRadia;    /** Radia of regions for each layer **/

  Int_t             fNLayers;          /** Number of layers in the MUCH system (gaps between absorbers + 1) **/
  Int_t             fNStationsPerLayer;/** Number of stations in each layer **/
  Int_t             fNStations;        /** Total number of stations **/
  Bool_t            fCreateEps;        /** Switch showing whether to create eps figures for stations **/


  enum PlainPart {kMain, kGaps};
  /** Makes segmentation for a given station/layer **/
  void MakeSegmentation(Int_t iLayer);
  /** Defines sector size for each region **/
  void SetSectorSizes(int nRegions, double minSecLx, double minSecLy, std::vector<double>& secLx, std::vector<double>& secLy);

  Bool_t IntersectsRegion(Double_t iRadius, Double_t x1, Double_t y1, Double_t x2, Double_t y2);
  Bool_t IntersectsPave(TPave* pave, TVector2 p1, TVector2 p2, TVector2 p3, TVector2 p4);
  Bool_t IntersectsPaves(std::vector<TPave*> paves, TVector2 p1, TVector2 p2, TVector2 p3, TVector2 p4);
  Bool_t IntersectsFifty(Double_t iRadius, Double_t x1, Double_t y1, Double_t x2, Double_t y2);
  void DrawPave(Double_t x1, Double_t y1, Double_t x2, Double_t y2, std::vector<TPave*>& paves, Int_t iColor);
  void DrawPaves(Double_t rad1, Double_t rad2, Double_t width, Double_t height, 
		 std::vector<TPave*>& paves, Int_t iColor, PlainPart iPart);
  void CalculateMinimalSizes(int iLayer);
  void CreateAsciiInputPads(int iLayer, int iType, std::vector<TPave*> paves);
/*   void CreateAsciiInputStrips(int iLayer, int iType, std::vector<TPave*> paves, */
/* 			      double minSecLx, double minSecLy, double minPadLx, double minPadLy); */


  ClassDef(CbmMuchSegmentation,1)
};

#endif