KVINDRA.h

Go to the documentation of this file.

/***************************************************************************
                          kvindra.h  -  description
                             -------------------
    begin                : Mon May 20 2002
    copyright            : (C) 2002 by J.D. Frankland
    email                : frankland@ganil.fr
 
$Id: KVINDRA.h,v 1.43 2009/01/21 10:05:51 franklan Exp $
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef KVINDRA_H
#define KVINDRA_H
 
#include "TEnv.h"
#include "KVASMultiDetArray.h"
#include "KVList.h"
#include "KVHashList.h"
#include "KVACQParam.h"
#include "KVDBSystem.h"
#include "KVUpDater.h"
#include "KVDataSetManager.h"
#include "KVINDRATriggerInfo.h"
#include "KVINDRADetector.h"
#include "KVINDRATelescope.h"
 
class KVLayer;
class KVNucleus;
class KVChIo;
class KVDetectorEvent;
class KVINDRAReconEvent;
 
enum EBaseIndra_type {
   ChIo_GG = 1,
   ChIo_PG,                     //=2
   ChIo_T,                      //=3
   Si_GG,                       //=4
   Si_PG,                       //=5
   Si_T,                        //=6
   CsI_R,                       //=7
   CsI_L,                       //=8
   CsI_T,                       //=9
   Si75_GG,                     //=10
   Si75_PG,                     //=11
   Si75_T,                      //=12
   SiLi_GG,                     //=13
   SiLi_PG,                     //=14
   SiLi_T                       //=15
};
enum EBaseIndra_typePhos {
   Phos_R = 1,
   Phos_L,                      //=2
   Phos_T,                      //=3
};
 
class KVINDRA: public KVASMultiDetArray {
 
public:
    static Char_t SignalTypes[16][3];
 
 
private:
    UChar_t fTrigger;
    KVList fOwnedACQParams;
 
   void AddArrayACQParam(KVACQParam* p)
   {
      fOwnedACQParams.Add(p);
      AddACQParam(p);
   }
 
protected:
    KVHashList* fChIo;
    KVHashList* fSi;
    KVHashList* fCsI;
    KVHashList* fPhoswich;
 
    Bool_t fPHDSet;
 
    KVINDRATriggerInfo* fSelecteur;
 
    TEnv fStrucInfos;
 
   virtual void MakeListOfDetectors();
   virtual void BuildGeometry();
   virtual void SetGroupsAndIDTelescopes();
   void FillListsOfDetectorsByType();
   void SetGGtoPGConversionFactors();
   void LinkToCodeurs();
   void BuildLayer(const Char_t* name);
   KVRing* BuildRing(Int_t number, const Char_t* prefix);
   KVINDRATelescope* BuildTelescope(const Char_t* prefix, Int_t mod);
   void FillTrajectoryIDTelescopeLists();
   Int_t GetIDTelescopes(KVDetector*, KVDetector*, TCollection*);
   void SetNamesOfIDTelescopes() const;
 
   void PerformClosedROOTGeometryOperations();
#ifdef WITH_MFM
   Bool_t handle_raw_data_event_mfmframe_ebyedat(const MFMEbyedatFrame&);
#endif
   void SetIDCodeForIDTelescope(KVIDTelescope*) const;
 
   virtual UShort_t GetBadIDCode()
   {
      return IDCodes::NO_IDENTIFICATION;
   }
   virtual UShort_t GetCoherencyIDCode()
   {
      return IDCodes::ID_CI_SI_COHERENCY;
   }
   virtual UShort_t GetMultiHitFirstStageIDCode()
   {
      return IDCodes::ID_CI_MULTIHIT;
   }
   virtual UChar_t GetNormalCalibrationCode()
   {
      return ECodes::NORMAL_CALIBRATION;
   }
 
public:
   enum IDCodes {
      NO_IDENTIFICATION = 14, 
      ID_STOPPED_IN_FIRST_STAGE = 5, 
      ID_GAMMA = 0, 
      ID_NEUTRON = 1, 
      ID_PHOSWICH = 2, 
      ID_CSI_PSA = 2, 
      ID_SI_CSI = 3, 
      ID_SI75_SILI = 3, 
      ID_SILI_CSI = 3, 
      ID_CI_SI = 4, 
      ID_CI_CSI = 4, 
      ID_CI_SI75 = 4, 
      ID_CI_SI_COHERENCY = 6, 
      ID_CI_COHERENCY = 7, 
      ID_CI_MULTIHIT = 8, 
      ID_CSI_FRAGMENT = 9, 
      ID_CSI_MASS_OUT_OF_RANGE = 10 
   };
   TString GetIDCodeMeaning(Int_t idc) const
   {
      switch (idc) {
         case NO_IDENTIFICATION:
            return "NO_IDENTIFICATION";
         case ID_STOPPED_IN_FIRST_STAGE:
            return "ID_STOPPED_IN_FIRST_STAGE";
         case ID_GAMMA:
            return "ID_GAMMA";
         case ID_NEUTRON:
            return "ID_NEUTRON";
         case ID_CSI_PSA:
            return "ID_CSI_PSA";
         case ID_SI_CSI:
            return "ID_SI_CSI";
         case ID_CI_SI:
            return "ID_CI_CSI";
         case ID_CSI_FRAGMENT:
            return "ID_CSI_FRAGMENT";
         case ID_CSI_MASS_OUT_OF_RANGE:
            return "ID_CSI_MASS_OUT_OF_RANGE";
         default:
            return Form("(unknown:%d)", idc);
      }
   }
   enum ECodes {
      NO_CALIBRATION_ATTEMPTED = 0, 
      NORMAL_CALIBRATION = 1,       
      SOME_ENERGY_LOSSES_CALCULATED = 2, 
      WARNING_CSI_MAX_ENERGY = 3,    
      BAD_CALIBRATION = 15          
   };
   TString GetECodeMeaning(Int_t ec) const
   {
      switch (ec) {
         case NO_CALIBRATION_ATTEMPTED:
            return "NO_CALIBRATION_ATTEMPTED";
         case NORMAL_CALIBRATION:
            return "NORMAL_CALIBRATION";
         case SOME_ENERGY_LOSSES_CALCULATED:
            return "SOME_ENERGY_LOSSES_CALCULATED";
         case WARNING_CSI_MAX_ENERGY:
            return "WARNING_CSI_MAX_ENERGY";
         case BAD_CALIBRATION:
            return "BAD_CALIBRATION";
         default:
            return Form("(unknown:%d)", ec);
      }
   }
   virtual Int_t GetIDCodeForParticlesStoppingInFirstStageOfTelescopes() const
   {
      return IDCodes::ID_STOPPED_IN_FIRST_STAGE;
   }
 
   KVINDRA();
   virtual ~ KVINDRA();
 
   virtual void Build(Int_t run = -1);
   virtual Bool_t ArePHDSet() const
   {
      return fPHDSet;
   }
   virtual void PHDSet(Bool_t yes = kTRUE)
   {
      fPHDSet = yes;
   }
 
   KVLayer* GetChIoLayer();
   inline KVHashList* GetListOfChIo() const
   {
      return fChIo;
   };
   inline KVHashList* GetListOfSi() const
   {
      return fSi;
   };
   inline KVHashList* GetListOfCsI() const
   {
      return fCsI;
   };
   inline KVHashList* GetListOfPhoswich() const
   {
      return fPhoswich;
   };
 
   virtual KVChIo* GetChIoOf(const Char_t* detname);
   virtual void cd(Option_t* option = "");
   virtual KVINDRADetector* GetDetectorByType(UInt_t cou, UInt_t mod,
         UInt_t type) const;
 
   void SetTrigger(UChar_t trig);
   UChar_t GetTrigger() const
   {
      return fTrigger;
   }
 
   void SetPinLasersForCsI();
   virtual TGraph* GetPedestals(const Char_t* det_signal, const Char_t* det_type, Int_t ring_number, Int_t run_number = -1);
 
   void SetArrayACQParams();
   virtual void GetDetectorEvent(KVDetectorEvent* detev, const TSeqCollection* fired_params = 0);
 
   KVINDRATriggerInfo* GetTriggerInfo()
   {
      return fSelecteur;
   };
 
   void CreateROOTGeometry();
 
   virtual void SetROOTGeometry(Bool_t on = kTRUE);
   void SetMinimumOKMultiplicity(KVEvent*) const;
   KVGroupReconstructor* GetReconstructorForGroup(const KVGroup*) const;
   void SetReconParametersInEvent(KVReconstructedEvent*) const;
 
   ClassDef(KVINDRA, 6)        //class describing the materials and detectors etc. to build an INDRA multidetector array
};
 
R__EXTERN KVINDRA* gIndra;
 
inline void KVINDRA::cd(Option_t*)
{
   gIndra = this;
}
 
#endif