vistpc.h

Go to the documentation of this file.

#ifndef __VISTPC_H__
#define __VISTPC_H__

#include "TBBQManager.h"

// C++

#include <map>
#include <string>
#include <vector>

// ROOT

class TGeoMaterial;
class TGeoMedium;
class TGeoVolume;

// Eve

class TEveBoxSet;
class TEveElement;
class TEvePointSet;
class TEveQuadSet;
class TEveStraightLineSet;

// GEAR

namespace gear {
   class GearMgr;
   class TPCModule;
   class TPCParameters;
}

#ifndef __CINT__
#include "gearimpl/Vectors.h"
#else
namespace gear {
   class Vector2D;
}
#endif

// LCIO

#include "EVENT/TrackerHit.h"

namespace EVENT {
   class LCEvent;
   class TrackerHit;
}

namespace IMPL {
   class LCCollectionVec;
}

class VisTPC {
public:
   
   //---------------------------------------------------------------------------
   // Data types and structures

   enum LCCollectionType_enum {
      kUNDEFINEDTYPE,
      kPULSE,
      kHIT,
      kTRACK
   };
   
   enum LeftRight_enum {
      kLEFT,
      kRIGHT
   };

   struct PadMetric {
      int coordinate_system;
      
      float height;
      float width;
      
      float center_x;
      float center_y;
      
      float center_r;
      float center_phi;
      
      float corners_polar[8];
      float corners_cartesian[8];
   };
   
   //---------------------------------------------------------------------------
   // Constructor

   VisTPC(gear::GearMgr * aGearMgr = 0);
   ~VisTPC() {};
   
   //---------------------------------------------------------------------------
   
   
   float getReadoutFrequency()               {return readoutFrequency;}
   float getDriftVelocity()                  {return driftVelocity;}
   float getMaxDriftLength()                 {return maxDriftLength;}
   int   getMaxPoints()                      {return maxPoints;}
   int   getOption(std::string& option)      {
      std::map<std::string, int>::iterator it = options.find(option);
      
      if (it == options.end())
         throw "Option not found";
      
      return options[option];
   }
   
   void setReadoutFrequency(float frequency) {readoutFrequency = frequency;}
   void setDriftVelocity(float velocity)     {driftVelocity = velocity;}
   void setMaxDriftLength(float length)      {maxDriftLength = length;}
   void setMaxPoints(int points)             {maxPoints = points;}
   void setOption(std::string option, int value) {options[option] = value;}
   

   //---------------------------------------------------------------------------
   
   void drawTPC();
   
   void drawModule(gear::TPCModule* aModule, TEveElement* parent = NULL);
   void drawModules(TEveElement* parent = NULL);
   
   void drawPads(gear::TPCModule* aModule, TEveElement* parent = NULL);
   
   
   //---------------------------------------------------------------------------
   
   void         drawEvent(EVENT::LCEvent* event, std::vector<std::string> &selectedEntries, TEveElement* parent = NULL, const char* name = "Event");
   void         drawEvent(EVENT::LCEvent* event, TList &selectedEntries,                    TEveElement* parent = NULL, const char* name = "Event");
   void         drawHit(EVENT::TrackerHit* hit, TEvePointSet* parent, int wantTooltip = false);
   TEveElement* drawHits(IMPL::LCCollectionVec* hits, int wantTooltip = true);
   TEveElement* drawHits(const EVENT::TrackerHitVec& hits, int wantTooltip = true);
   TEveElement* drawPulses(IMPL::LCCollectionVec* pulses);
   TEveElement* drawTracks(IMPL::LCCollectionVec* tracks, TEveElement* parent = NULL);
   
   
   //---------------------------------------------------------------------------

   void drawCircularPolygon(TEveStraightLineSet* ls, float r, int nDivisions, float z);
   void drawCircularPolygon(TEveStraightLineSet* ls, float r, float phi_min, float phi_max, int nDivisions, float z);

   void drawPadBox(const PadMetric& pad, float z_front, float z_back, TEveBoxSet* bs);
   void drawPadQuad(const PadMetric& pad, float z, TEveQuadSet* qs);
   
   const LCCollectionType_enum getCollectionType(const std::string&);

   void getGlobalPadMetric(const gear::TPCModule * aModule, const int padIndex, PadMetric& pad);
   
   void getLocalPadMetric(const gear::TPCModule * aModule, const int padIndex, PadMetric& pad);
   
   void toGlobal(const gear::TPCModule * aModule, TEveElement* element);
   

   //---------------------------------------------------------------------------
   
   void drawTwoConnectingPads(const gear::TPCModule& aModule, TEveElement* parent, int pad1, int pad2, LeftRight_enum leftright);
   void drawNearestPad(const gear::TPCModule& aModule, TEveElement* parent, int padIndex, const gear::Vector2D& position, int i);

   void testLeftRightNeighbour(int moduleID = 0);
   void testLeftRightNeighbourWithPads(int moduleID, const std::vector<int>& pads, LeftRight_enum leftright);
   
   void testNearestPad(int moduleID = 0);
   void testNearestPadWithPoints(int moduleID, const std::vector<gear::Vector2D>& points);
   
   void testNearestPadGlobal();
   void testNearestPadGlobalWithPoints(const std::vector<gear::Vector2D>& points);
   

   void updateGearMgr( gear::GearMgr * aGearMgr );

   //---------------------------------------------------------------------------
   // Variables
protected:

   int debug;



   gear::GearMgr *             gearMgr;
   gear::TPCParameters const * tpcParameters;



   std::map<std::string, TGeoMaterial*> materials;
   std::map<std::string, TGeoMedium*>   media;
   std::map<std::string, TGeoVolume*>   volumes;
   
   
   
   float readoutFrequency;
   float driftVelocity;
   
   float maxDriftLength;
   

   
   std::map<std::string, int> options;
   
   
   int maxPoints;
   
   float outerFieldCageRadius; 
   float innerFieldCageRadius; 

private:
   ClassDef(VisTPC, 1);
};

#endif