LCOV - code coverage report
Current view: top level - MUON/MUONmapping - AliMpCDB.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 4 25.0 %
Date: 2016-06-14 17:26:59 Functions: 1 9 11.1 %

          Line data    Source code
       1             : #ifndef ALI_MP_CDB_H
       2             : #define ALI_MP_CDB_H
       3             : 
       4             : /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
       5             :  * See cxx source for full Copyright notice                               */
       6             : 
       7             : // $Id$ 
       8             : 
       9             : /// \ingroup management
      10             : /// \class AliMpCDB
      11             : /// \brief Manager class for mapping CDB IO
      12             : ///
      13             : /// The mapping can be loaded in two ways:
      14             : /// - from mapping objects stored in the CDB folders Mapping, DDLStore
      15             : ///   (old way)
      16             : /// - from mapping data store in a form of string map in the CDB 
      17             : ///   folder MappingData (new way, now default)
      18             : ///
      19             : /// To switch between these two ways:
      20             : /// - AliMpCDB::SetLoadFromData(Bool_t);
      21             : /// 
      22             : /// Now it is also possible to regenerate mapping ASCII data
      23             : /// from the string map:
      24             : /// - AliMpCDB::GenerateMpData();
      25             : ///
      26             : /// \author Ivana Hrivnacova, IPN Orsay
      27             : 
      28             : #ifndef ROOT_TObject
      29             : #  include <TObject.h>
      30             : #endif
      31             : 
      32             : class AliMpSegmentation;
      33             : class AliMpDDLStore;
      34             : 
      35           0 : class AliMpCDB : public  TObject {
      36             : 
      37             :   public:
      38             :     // static methods
      39             :     //
      40             : 
      41             :     static Bool_t LoadMpSegmentation(Bool_t warn = false);
      42             :     static Bool_t LoadDDLStore(Bool_t warn = false);
      43             :     static Bool_t LoadManuStore(Bool_t warn = false);
      44             :     static Bool_t LoadAll(Bool_t warn = false);
      45             :   
      46             :     static Bool_t LoadMpSegmentation2(
      47             :                     const char* cdbpath = "local://$ALICE_ROOT/OCDB",
      48             :                     Int_t runNumber = 0,
      49             :                     Bool_t warn = false);
      50             :     static Bool_t LoadDDLStore2(
      51             :                     const char* cdbpath = "local://$ALICE_ROOT/OCDB",
      52             :                     Int_t runNumber = 0,
      53             :                     Bool_t warn = false);
      54             :     static Bool_t LoadManuStore2(
      55             :                     const char* cdbpath = "local://$ALICE_ROOT/OCDB",
      56             :                     Int_t runNumber = 0,
      57             :                     Bool_t warn = false);
      58             :     static Bool_t LoadAll2(const char* cdbpath = "local://$ALICE_ROOT/OCDB",
      59             :                     Int_t runNumber = 0,
      60             :                     Bool_t warn = false);
      61             : 
      62             :   static Bool_t WriteMpData();
      63             :   static Bool_t WriteMpRunData();
      64             : 
      65             :   static Bool_t WriteMpData(Int_t startRun, Int_t endRun);
      66             :   static Bool_t WriteMpRunData(Int_t startRun, Int_t endRun);
      67             :   
      68             :     static Bool_t WriteMpSegmentation(Bool_t readData = true);
      69             :     static Bool_t WriteDDLStore(Bool_t readData= true);
      70             :     static Bool_t WriteManuStore(Bool_t readData= true);
      71             :     
      72             :     static Bool_t GenerateMpData(
      73             :                     const char* cdbpath = "local://$ALICE_ROOT/OCDB",
      74             :                     Int_t runNumber = 0);
      75             :     static Bool_t GenerateMpRunData(
      76             :                     const char* cdbpath = "local://$ALICE_ROOT/OCDB",
      77             :                     Int_t runNumber = 0);
      78             : 
      79             :     // Switch loading
      80             :     static void SetLoadFromData(Bool_t loadFromData);
      81             :      
      82             :   // Unload mapping
      83             :   
      84             :   static void UnloadAll(); 
      85             :   
      86             :   private:
      87             :     /// Not implemented
      88             :     AliMpCDB();
      89             :     /// Not implemented
      90             :     AliMpCDB(const AliMpCDB& rhs);
      91             :     /// Not implemented
      92             :     AliMpCDB& operator=(const AliMpCDB& rhs);
      93             :     
      94             : 
      95             :     static TObject*  GetCDBEntryObject(const char* dataPath);
      96             :     static TObject*  GetCDBEntryObject(const char* dataPath, 
      97             :                                        const char* cdbpath, 
      98             :                                        Int_t runNumber);
      99             :                                        
     100             :     static Bool_t fgLoadFromData; ///< option for loading from CDB mapping data or from CDB mapping objects 
     101             :     
     102          18 :   ClassDef(AliMpCDB,0)  // The factory for building mapping segmentations
     103             : };
     104             : 
     105             : // inline functions
     106             : 
     107             : inline void AliMpCDB::SetLoadFromData(Bool_t loadFromData)
     108             : {
     109             : /// Set option for loading from CDB mapping data or from CDB mapping objects
     110             : 
     111           0 :   fgLoadFromData = loadFromData;
     112           0 : }  
     113             :    
     114             : #endif //ALI_MP_CDB_H
     115             : 
     116             : 
     117             : 
     118             : 
     119             : 
     120             : 
     121             : 
     122             : 
     123             : 
     124             : 
     125             : 
     126             : 
     127             : 
     128             : 
     129             : 

Generated by: LCOV version 1.11