[u/mrichter/AliRoot.git] / MUON / mapping / AliMpCDB.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

// $Id$
// $MpId: $
// Category: management

//-----------------------------------------------------------------------------
// Class AliMpCDB
// -----------------------
// Manager class for mapping CDB IO
// Author: Ivana Hrivnacova, IPN Orsay
//-----------------------------------------------------------------------------

#include "AliMpCDB.h"

#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliLog.h"
#include "AliMpDDLStore.h"
#include "AliMpDEStore.h"
#include "AliMpDataMap.h"
#include "AliMpDataProcessor.h"
#include "AliMpDataStreams.h"
#include "AliMpManuStore.h"
#include "AliMpSegmentation.h"
#include <Riostream.h>
#include <TClass.h>
#include <TSystem.h>

/// \cond CLASSIMP
ClassImp(AliMpCDB)
/// \endcond

Bool_t AliMpCDB::fgLoadFromData = kTRUE;                                       

//
// private static methods
//

//______________________________________________________________________________
TObject*  AliMpCDB::GetCDBEntryObject(const char* dataPath)
{
/// Load CDB entry object with checks

  AliCDBManager* cdbManager = AliCDBManager::Instance();

  Int_t run = cdbManager->GetRun();
  if ( run < 0 ) {
    AliErrorClassStream() << "Cannot get run number from CDB manager." << endl; 
    return 0;
  }  

  AliCDBEntry* cdbEntry = cdbManager->Get(dataPath, run);
  if ( ! cdbEntry ) {
    AliErrorClassStream() << "Cannot get cdbEntry." << endl; 
    return 0;
  }
  
  TObject* object = cdbEntry->GetObject();
  if ( ! object ) {
    AliErrorClassStream() << "Cannot get object from cdbEntry." << endl; 
    return 0;
  }  

  return object;
}    
  

//______________________________________________________________________________
TObject*  AliMpCDB::GetCDBEntryObject(const char* dataPath, 
                                      const char* cdbpath,
                                      Int_t runNumber )
{
/// Load CDB entry from CDB and run specified in arguments

  AliCDBManager* cdbManager = AliCDBManager::Instance();
  cdbManager->SetDefaultStorage(cdbpath);

  AliCDBEntry* cdbEntry = cdbManager->Get(dataPath, runNumber);
  if ( ! cdbEntry ) {
    AliErrorClassStream() << "Cannot get cdbEntry." << endl; 
    return 0;
  }  
    
  TObject* object = cdbEntry->GetObject();
  if ( ! object ) {
    AliErrorClassStream() << "Cannot get object from cdbEntry." << endl; 
    return 0;
  }  

  return object;
}    
                                      
//
// public static methods
//

   
//______________________________________________________________________________
Bool_t AliMpCDB::LoadMpSegmentation(Bool_t warn)
{
/// Load the sementation from the mapping data from OCDB,
///  if it does not yet exist;
/// return false only in case loading from CDB failed

  if ( AliMpSegmentation::Instance(false) ) {
    if ( warn )  
      AliWarningClass("Segmentation has been already loaded."); 
    return true;
  }  
  
  if ( fgLoadFromData ) {
    AliDebugClassStream(1)
      << "Loading segmentation from MUON/Calib/MappingData" << endl;
  
    TObject* cdbEntryObject = GetCDBEntryObject("MUON/Calib/MappingData");
    if ( ! cdbEntryObject ) return kFALSE;
  
    // Pass the map to the streams and then read segmentation
    // from data map
    AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
    AliMpDataStreams dataStreams(dataMap);
    AliMpSegmentation::ReadData(dataStreams);
    return kTRUE;
  }
  else {
    AliDebugClassStream(1)
      << "Loading segmentation from MUON/Calib/Mapping" << endl;
  
    TObject* cdbEntryObject = GetCDBEntryObject("MUON/Calib/Mapping");
    return cdbEntryObject != 0x0;
  }  
}    

//______________________________________________________________________________
Bool_t AliMpCDB::LoadDDLStore(Bool_t warn)
{
/// Load the DDL store from the mapping data from OCDB,
///  if it does not yet exist;
/// return false only in case loading from CDB failed

  if ( AliMpDDLStore::Instance(false) ) {
    if ( warn )  
      AliWarningClass("DDL Store has been already loaded."); 
    return true;
  }  
  
  if ( fgLoadFromData ) {
    AliDebugClassStream(1)
      << "Loading DDL store from MUON/Calib/MappingData" << endl;
  
    TObject* cdbEntryObject = GetCDBEntryObject("MUON/Calib/MappingData");
    if ( ! cdbEntryObject ) return kFALSE;
  
    AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
    AliMpDataStreams dataStreams(dataMap);
    AliMpDDLStore::ReadData(dataStreams);
    return kTRUE;
  }
  else {
    AliDebugClassStream(1)
      << "Loading DDL store from MUON/Calib/DDLStore" << endl;
  
    // Load segmentation
    LoadMpSegmentation(warn); 
  
    // Load DDL store
    TObject* cdbEntryObject =  GetCDBEntryObject("MUON/Calib/DDLStore");
    return cdbEntryObject != 0x0;
  }     
}    

//______________________________________________________________________________
Bool_t AliMpCDB::LoadManuStore(Bool_t warn)
{
/// Load the DDL store from the mapping data from OCDB,
///  if it does not yet exist;
/// return false only in case loading from CDB failed

  if ( AliMpManuStore::Instance(false) ) {
    if ( warn )  
      AliWarningClass("Manu Store has been already loaded."); 
    return true;
  }  
  
  if ( fgLoadFromData ) {
    AliDebugClassStream(1)
      << "Loading Manu store from MUON/Calib/MappingRunData" << endl;
  
    // Load segmentation
    LoadMpSegmentation(warn); 

    TObject* cdbEntryObject = GetCDBEntryObject("MUON/Calib/MappingRunData");
    if ( ! cdbEntryObject ) return kFALSE;
  
    AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
    AliMpDataStreams dataStreams(dataMap);
    AliMpManuStore::ReadData(dataStreams);
    return kTRUE;
  }
  else {
    AliDebugClassStream(1)
      << "Loading Manu store from MUON/Calib/ManuStore" << endl;
  
    // Load Manu store
    TObject* cdbEntryObject =  GetCDBEntryObject("MUON/Calib/ManuStore");
    return cdbEntryObject != 0x0;
  }     
}    
//______________________________________________________________________________
Bool_t AliMpCDB::LoadMpSegmentation2(const char* cdbpath, Int_t runNumber, 
                                     Bool_t warn)
{
/// Load the sementation from the CDB if it does not yet exist;
/// return false only in case loading from CDB failed.
/// In difference from LoadMpSegmentation(), in this method the CDB path
/// and run is set directly via arguments.


  if ( AliMpSegmentation::Instance(false) ) {
    if ( warn )  
      AliWarningClass("Segmentation has been already loaded."); 
    return true;
  }  
  
  if ( fgLoadFromData ) {
    AliDebugClassStream(1)
      << "Loading segmentation from MUON/Calib/MappingData" << endl;
  
    TObject* cdbEntryObject 
      = GetCDBEntryObject("MUON/Calib/MappingData", cdbpath, runNumber);
    if ( ! cdbEntryObject ) return kFALSE;
  
    // Pass the map to the streams and then read segmentation
    // from data map
    AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
    AliMpDataStreams dataStreams(dataMap);
    AliMpSegmentation::ReadData(dataStreams);
    return kTRUE;
  }
  else {
    AliDebugClassStream(1)
      << "Loading segmentation from MUON/Calib/Mapping" << endl;
  
    TObject* cdbEntryObject 
      = GetCDBEntryObject("MUON/Calib/Mapping", cdbpath, runNumber);
    return cdbEntryObject != 0x0;
  }  
}    

//______________________________________________________________________________
Bool_t AliMpCDB::LoadDDLStore2(const char* cdbpath, Int_t runNumber, 
                               Bool_t warn)
{
/// Load the DDL store from the CDB if it does not yet exist
/// return false only in case loading from CDB failed
/// In difference from LoadDDLStore(), in this method the CDB path
/// and run is set directly via arguments.

  if ( AliMpDDLStore::Instance(false) ) {
    if ( warn )  
      AliWarningClass("DDL Store has been already loaded."); 
    return true;
  }  
  
  if ( fgLoadFromData ) {
    AliDebugClassStream(1)
      << "Loading DDL store from MUON/Calib/MappingData" << endl;
  
    TObject* cdbEntryObject 
      = GetCDBEntryObject("MUON/Calib/MappingData", cdbpath, runNumber);
    if ( ! cdbEntryObject ) return kFALSE;
  
    AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
    AliMpDataStreams dataStreams(dataMap);
    AliMpDDLStore::ReadData(dataStreams);
    return kTRUE;
  }
  else {
    AliDebugClassStream(1)
      << "Loading DDL store from MUON/Calib/DDLStore" << endl;
  
    // Load segmentation
    LoadMpSegmentation2(cdbpath, runNumber, warn); 
  
    // Load DDL store
    TObject* cdbEntryObject =  GetCDBEntryObject("MUON/Calib/DDLStore");
    return cdbEntryObject != 0x0;
  }  
}    

//______________________________________________________________________________
Bool_t AliMpCDB::LoadManuStore2(const char* cdbpath, Int_t runNumber, 
                                Bool_t warn)
{
/// Load the DDL store from the CDB if it does not yet exist
/// return false only in case loading from CDB failed
/// In difference from LoadDDLStore(), in this method the CDB path
/// and run is set directly via arguments.

  if ( AliMpManuStore::Instance(false) ) {
    if ( warn )  
      AliWarningClass("Manu Store has been already loaded."); 
    return true;
  }  
  
  if ( fgLoadFromData ) {
    AliDebugClassStream(1)
      << "Loading Manu store from MUON/Calib/MappingRunData" << endl;
  
    // Load segmentation
    LoadMpSegmentation2(cdbpath, runNumber, warn); 

    TObject* cdbEntryObject 
      = GetCDBEntryObject("MUON/Calib/MappingRunData", cdbpath, runNumber);
    if ( ! cdbEntryObject ) return kFALSE;
  
    AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
    AliMpDataStreams dataStreams(dataMap);
    AliMpManuStore::ReadData(dataStreams);
    return kTRUE;
  }
  else {
    AliDebugClassStream(1)
      << "Loading Manu store from MUON/Calib/ManuStore" << endl;
  
    // Load Manu store
    TObject* cdbEntryObject =  GetCDBEntryObject("MUON/Calib/ManuStore");
    return cdbEntryObject != 0x0;
  }  
}    

//______________________________________________________________________________
Bool_t AliMpCDB::WriteMpData()
{
/// Write mapping data in OCDB

  AliCDBManager* cdbManager = AliCDBManager::Instance();
  if ( ! cdbManager->GetDefaultStorage() )
    cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  
  AliCDBMetaData* cdbData = new AliCDBMetaData();
  cdbData->SetResponsible("Dimuon Offline project");
  cdbData->SetComment("MUON mapping");
  cdbData->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
  AliCDBId id("MUON/Calib/MappingData", 0, AliCDBRunRange::Infinity()); 

  AliMpDataProcessor mp;
  AliMpDataMap* map = mp.CreateDataMap("data");
  return cdbManager->Put(map, id, cdbData);
}

//______________________________________________________________________________
Bool_t AliMpCDB::WriteMpRunData()
{
/// Write mapping data in OCDB

  AliCDBManager* cdbManager = AliCDBManager::Instance();
  if ( ! cdbManager->GetDefaultStorage() )
    cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  
  AliCDBMetaData* cdbData = new AliCDBMetaData();
  cdbData->SetResponsible("Dimuon Offline project");
  cdbData->SetComment("MUON run-dependent mapping");
  cdbData->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
  AliCDBId id("MUON/Calib/MappingRunData", 0, AliCDBRunRange::Infinity()); 

  AliMpDataProcessor mp;
  AliMpDataMap* map = mp.CreateDataMap("data_run");
  return cdbManager->Put(map, id, cdbData);
}

//______________________________________________________________________________
Bool_t AliMpCDB::WriteMpSegmentation(Bool_t readData)
{
/// Write mapping segmentation in OCDB

  if ( ! readData && ! AliMpSegmentation::Instance() ) return false;

  AliCDBManager* cdbManager = AliCDBManager::Instance();
  if ( ! cdbManager->GetDefaultStorage() )
    cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  
  AliCDBMetaData* cdbData = new AliCDBMetaData();
  cdbData->SetResponsible("Dimuon Offline project");
  cdbData->SetComment("MUON mapping");
  cdbData->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
  AliCDBId id("MUON/Calib/Mapping", 0, AliCDBRunRange::Infinity()); 

  if ( readData ) {
    AliMpDataStreams dataStreams;
    AliMpSegmentation::ReadData(dataStreams, false);
    AliMpDDLStore::ReadData(dataStreams, false);
  }
  
  return cdbManager->Put(AliMpSegmentation::Instance(), id, cdbData);
}

//______________________________________________________________________________
Bool_t AliMpCDB::WriteDDLStore(Bool_t readData)
{
/// Write mapping DDL store in OCDB

  if ( ! readData && ! AliMpDDLStore::Instance() ) return false;

  AliCDBManager* cdbManager = AliCDBManager::Instance();
  if ( ! cdbManager->GetDefaultStorage() )
    cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  
  AliCDBMetaData* cdbData = new AliCDBMetaData();
  cdbData->SetResponsible("Dimuon Offline project");
  cdbData->SetComment("MUON DDL store");
  cdbData->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
  AliCDBId id("MUON/Calib/DDLStore", 0, AliCDBRunRange::Infinity()); 

  if ( readData ) {
    AliMpDataStreams dataStreams;
    AliMpSegmentation::ReadData(dataStreams, false);
    AliMpDDLStore::ReadData(dataStreams, false);
  }
  return cdbManager->Put(AliMpDDLStore::Instance(), id, cdbData);
}   

//______________________________________________________________________________
Bool_t AliMpCDB::WriteManuStore(Bool_t readData)
{
/// Write mapping Manu store in OCDB

  if ( ! readData && ! AliMpManuStore::Instance() ) return false;

  AliCDBManager* cdbManager = AliCDBManager::Instance();
  if ( ! cdbManager->GetDefaultStorage() )
    cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
  
  AliCDBMetaData* cdbData = new AliCDBMetaData();
  cdbData->SetResponsible("Dimuon Offline project");
  cdbData->SetComment("MUON Manu store");
  cdbData->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
  AliCDBId id("MUON/Calib/ManuStore", 0, AliCDBRunRange::Infinity()); 

  if ( readData ) {
    AliMpDataStreams dataStreams;
    AliMpSegmentation::ReadData(dataStreams, false);
    AliMpManuStore::ReadData(dataStreams, false);
  }
  return cdbManager->Put(AliMpManuStore::Instance(), id, cdbData);
}   

//______________________________________________________________________________
Bool_t  AliMpCDB::GenerateMpData(const char* cdbpath, Int_t runNumber)
{
/// Generate mapping data ASCII files from OCDB

  TObject* cdbEntryObject 
    = GetCDBEntryObject("MUON/Calib/MappingData", cdbpath, runNumber);
  if ( ! cdbEntryObject ) return kFALSE;
  
  AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
  AliMpDataProcessor mp;
  return mp.GenerateData(dataMap);
} 

//______________________________________________________________________________
Bool_t  AliMpCDB::GenerateMpRunData(const char* cdbpath, Int_t runNumber)
{
/// Generate mapping data ASCII files from OCDB

  TObject* cdbEntryObject 
    = GetCDBEntryObject("MUON/Calib/MappingRunData", cdbpath, runNumber);
  if ( ! cdbEntryObject ) return kFALSE;
  
  AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
  AliMpDataProcessor mp;
  return mp.GenerateData(dataMap);
} 

//______________________________________________________________________________
void AliMpCDB::UnloadAll()
{
  /// Unload all the mapping from the memory
  delete AliMpDDLStore::Instance(false);
  delete AliMpSegmentation::Instance(false);
  delete AliMpDEStore::Instance(false);
}
Commit	Line	Data
3f862c88	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	// $Id$
	17	// $MpId: $
	18	// Category: management
	19
3d1463c8	20	//-----------------------------------------------------------------------------
3f862c88	21	// Class AliMpCDB
	22	// -----------------------
	23	// Manager class for mapping CDB IO
	24	// Author: Ivana Hrivnacova, IPN Orsay
3d1463c8	25	//-----------------------------------------------------------------------------
3f862c88	26
	27	#include "AliMpCDB.h"
	28
183279c1	29	#include "AliCDBEntry.h"
	30	#include "AliCDBManager.h"
	31	#include "AliLog.h"
3f862c88	32	#include "AliMpDDLStore.h"
183279c1	33	#include "AliMpDEStore.h"
183279c1	34	#include "AliMpDataMap.h"
228fd720	35	#include "AliMpDataProcessor.h"
228fd720	36	#include "AliMpDataStreams.h"
183279c1	37	#include "AliMpManuStore.h"
183279c1	38	#include "AliMpSegmentation.h"
ff5445c2	39	#include <Riostream.h>
183279c1	40	#include <TClass.h>
183279c1	41	#include <TSystem.h>
3f862c88	42
	43	/// \cond CLASSIMP
	44	ClassImp(AliMpCDB)
	45	/// \endcond
	46
228fd720	47	Bool_t AliMpCDB::fgLoadFromData = kTRUE;
228fd720	48
3f862c88	49	//
228fd720	50	// private static methods
3f862c88	51	//
707ad0dc	52
3f862c88	53	//______________________________________________________________________________
228fd720	54	TObject* AliMpCDB::GetCDBEntryObject(const char* dataPath)
3f862c88	55	{
228fd720	56	/// Load CDB entry object with checks
3f862c88	57
3f862c88	58	AliCDBManager* cdbManager = AliCDBManager::Instance();
3f862c88	59
	60	Int_t run = cdbManager->GetRun();
	61	if ( run < 0 ) {
0be76c28	62	AliErrorClassStream() << "Cannot get run number from CDB manager." << endl;
228fd720	63	return 0;
3f862c88	64	}
3f862c88	65
228fd720	66	AliCDBEntry* cdbEntry = cdbManager->Get(dataPath, run);
	67	if ( ! cdbEntry ) {
	68	AliErrorClassStream() << "Cannot get cdbEntry." << endl;
	69	return 0;
5699c0e6	70	}
228fd720	71
	72	TObject* object = cdbEntry->GetObject();
	73	if ( ! object ) {
	74	AliErrorClassStream() << "Cannot get object from cdbEntry." << endl;
	75	return 0;
	76	}
	77
	78	return object;
	79	}
	80
	81
	82	//______________________________________________________________________________
	83	TObject* AliMpCDB::GetCDBEntryObject(const char* dataPath,
	84	const char* cdbpath,
	85	Int_t runNumber )
	86	{
	87	/// Load CDB entry from CDB and run specified in arguments
	88
	89	AliCDBManager* cdbManager = AliCDBManager::Instance();
	90	cdbManager->SetDefaultStorage(cdbpath);
	91
	92	AliCDBEntry* cdbEntry = cdbManager->Get(dataPath, runNumber);
	93	if ( ! cdbEntry ) {
	94	AliErrorClassStream() << "Cannot get cdbEntry." << endl;
	95	return 0;
	96	}
	97
	98	TObject* object = cdbEntry->GetObject();
	99	if ( ! object ) {
	100	AliErrorClassStream() << "Cannot get object from cdbEntry." << endl;
	101	return 0;
	102	}
	103
	104	return object;
	105	}
	106
	107	//
	108	// public static methods
	109	//
	110
	111
	112	//______________________________________________________________________________
	113	Bool_t AliMpCDB::LoadMpSegmentation(Bool_t warn)
	114	{
	115	/// Load the sementation from the mapping data from OCDB,
	116	/// if it does not yet exist;
	117	/// return false only in case loading from CDB failed
	118
	119	if ( AliMpSegmentation::Instance(false) ) {
	120	if ( warn )
	121	AliWarningClass("Segmentation has been already loaded.");
	122	return true;
	123	}
	124
	125	if ( fgLoadFromData ) {
	126	AliDebugClassStream(1)
	127	<< "Loading segmentation from MUON/Calib/MappingData" << endl;
	128
	129	TObject* cdbEntryObject = GetCDBEntryObject("MUON/Calib/MappingData");
	130	if ( ! cdbEntryObject ) return kFALSE;
	131
	132	// Pass the map to the streams and then read segmentation
	133	// from data map
	134	AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
ab167304	135	AliMpDataStreams dataStreams(dataMap);
ab167304	136	AliMpSegmentation::ReadData(dataStreams);
228fd720	137	return kTRUE;
5699c0e6	138	}
228fd720	139	else {
	140	AliDebugClassStream(1)
	141	<< "Loading segmentation from MUON/Calib/Mapping" << endl;
	142
	143	TObject* cdbEntryObject = GetCDBEntryObject("MUON/Calib/Mapping");
	144	return cdbEntryObject != 0x0;
	145	}
3f862c88	146	}
	147
	148	//______________________________________________________________________________
	149	Bool_t AliMpCDB::LoadDDLStore(Bool_t warn)
	150	{
228fd720	151	/// Load the DDL store from the mapping data from OCDB,
228fd720	152	/// if it does not yet exist;
3f862c88	153	/// return false only in case loading from CDB failed
3f862c88	154
3f862c88	155	if ( AliMpDDLStore::Instance(false) ) {
	156	if ( warn )
	157	AliWarningClass("DDL Store has been already loaded.");
	158	return true;
	159	}
	160
228fd720	161	if ( fgLoadFromData ) {
	162	AliDebugClassStream(1)
	163	<< "Loading DDL store from MUON/Calib/MappingData" << endl;
707ad0dc	164
228fd720	165	TObject* cdbEntryObject = GetCDBEntryObject("MUON/Calib/MappingData");
228fd720	166	if ( ! cdbEntryObject ) return kFALSE;
3f862c88	167
228fd720	168	AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
ab167304	169	AliMpDataStreams dataStreams(dataMap);
ab167304	170	AliMpDDLStore::ReadData(dataStreams);
228fd720	171	return kTRUE;
5699c0e6	172	}
228fd720	173	else {
	174	AliDebugClassStream(1)
	175	<< "Loading DDL store from MUON/Calib/DDLStore" << endl;
	176
	177	// Load segmentation
	178	LoadMpSegmentation(warn);
	179
	180	// Load DDL store
	181	TObject* cdbEntryObject = GetCDBEntryObject("MUON/Calib/DDLStore");
	182	return cdbEntryObject != 0x0;
	183	}
3f862c88	184	}
3f862c88	185
ab167304	186	//______________________________________________________________________________
	187	Bool_t AliMpCDB::LoadManuStore(Bool_t warn)
	188	{
	189	/// Load the DDL store from the mapping data from OCDB,
	190	/// if it does not yet exist;
	191	/// return false only in case loading from CDB failed
	192
	193	if ( AliMpManuStore::Instance(false) ) {
	194	if ( warn )
	195	AliWarningClass("Manu Store has been already loaded.");
	196	return true;
	197	}
	198
	199	if ( fgLoadFromData ) {
	200	AliDebugClassStream(1)
	201	<< "Loading Manu store from MUON/Calib/MappingRunData" << endl;
	202
	203	// Load segmentation
	204	LoadMpSegmentation(warn);
	205
	206	TObject* cdbEntryObject = GetCDBEntryObject("MUON/Calib/MappingRunData");
	207	if ( ! cdbEntryObject ) return kFALSE;
	208
	209	AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
	210	AliMpDataStreams dataStreams(dataMap);
	211	AliMpManuStore::ReadData(dataStreams);
	212	return kTRUE;
	213	}
	214	else {
	215	AliDebugClassStream(1)
	216	<< "Loading Manu store from MUON/Calib/ManuStore" << endl;
	217
	218	// Load Manu store
	219	TObject* cdbEntryObject = GetCDBEntryObject("MUON/Calib/ManuStore");
	220	return cdbEntryObject != 0x0;
	221	}
	222	}
d3af4674	223	//______________________________________________________________________________
	224	Bool_t AliMpCDB::LoadMpSegmentation2(const char* cdbpath, Int_t runNumber,
	225	Bool_t warn)
	226	{
	227	/// Load the sementation from the CDB if it does not yet exist;
	228	/// return false only in case loading from CDB failed.
	229	/// In difference from LoadMpSegmentation(), in this method the CDB path
	230	/// and run is set directly via arguments.
	231
	232
d3af4674	233	if ( AliMpSegmentation::Instance(false) ) {
	234	if ( warn )
	235	AliWarningClass("Segmentation has been already loaded.");
	236	return true;
	237	}
	238
228fd720	239	if ( fgLoadFromData ) {
	240	AliDebugClassStream(1)
	241	<< "Loading segmentation from MUON/Calib/MappingData" << endl;
d3af4674	242
228fd720	243	TObject* cdbEntryObject
	244	= GetCDBEntryObject("MUON/Calib/MappingData", cdbpath, runNumber);
	245	if ( ! cdbEntryObject ) return kFALSE;
	246
	247	// Pass the map to the streams and then read segmentation
	248	// from data map
	249	AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
ab167304	250	AliMpDataStreams dataStreams(dataMap);
ab167304	251	AliMpSegmentation::ReadData(dataStreams);
228fd720	252	return kTRUE;
d3af4674	253	}
228fd720	254	else {
	255	AliDebugClassStream(1)
	256	<< "Loading segmentation from MUON/Calib/Mapping" << endl;
	257
	258	TObject* cdbEntryObject
	259	= GetCDBEntryObject("MUON/Calib/Mapping", cdbpath, runNumber);
	260	return cdbEntryObject != 0x0;
	261	}
d3af4674	262	}
	263
	264	//______________________________________________________________________________
	265	Bool_t AliMpCDB::LoadDDLStore2(const char* cdbpath, Int_t runNumber,
	266	Bool_t warn)
	267	{
	268	/// Load the DDL store from the CDB if it does not yet exist
	269	/// return false only in case loading from CDB failed
	270	/// In difference from LoadDDLStore(), in this method the CDB path
	271	/// and run is set directly via arguments.
	272
d3af4674	273	if ( AliMpDDLStore::Instance(false) ) {
	274	if ( warn )
	275	AliWarningClass("DDL Store has been already loaded.");
	276	return true;
	277	}
	278
228fd720	279	if ( fgLoadFromData ) {
	280	AliDebugClassStream(1)
	281	<< "Loading DDL store from MUON/Calib/MappingData" << endl;
d3af4674	282
228fd720	283	TObject* cdbEntryObject
	284	= GetCDBEntryObject("MUON/Calib/MappingData", cdbpath, runNumber);
	285	if ( ! cdbEntryObject ) return kFALSE;
d3af4674	286
228fd720	287	AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
ab167304	288	AliMpDataStreams dataStreams(dataMap);
ab167304	289	AliMpDDLStore::ReadData(dataStreams);
228fd720	290	return kTRUE;
d3af4674	291	}
228fd720	292	else {
	293	AliDebugClassStream(1)
	294	<< "Loading DDL store from MUON/Calib/DDLStore" << endl;
	295
	296	// Load segmentation
	297	LoadMpSegmentation2(cdbpath, runNumber, warn);
	298
	299	// Load DDL store
	300	TObject* cdbEntryObject = GetCDBEntryObject("MUON/Calib/DDLStore");
	301	return cdbEntryObject != 0x0;
	302	}
d3af4674	303	}
d3af4674	304
ab167304	305	//______________________________________________________________________________
	306	Bool_t AliMpCDB::LoadManuStore2(const char* cdbpath, Int_t runNumber,
	307	Bool_t warn)
	308	{
	309	/// Load the DDL store from the CDB if it does not yet exist
	310	/// return false only in case loading from CDB failed
	311	/// In difference from LoadDDLStore(), in this method the CDB path
	312	/// and run is set directly via arguments.
	313
	314	if ( AliMpManuStore::Instance(false) ) {
	315	if ( warn )
	316	AliWarningClass("Manu Store has been already loaded.");
	317	return true;
	318	}
	319
	320	if ( fgLoadFromData ) {
	321	AliDebugClassStream(1)
	322	<< "Loading Manu store from MUON/Calib/MappingRunData" << endl;
	323
	324	// Load segmentation
	325	LoadMpSegmentation2(cdbpath, runNumber, warn);
	326
	327	TObject* cdbEntryObject
	328	= GetCDBEntryObject("MUON/Calib/MappingRunData", cdbpath, runNumber);
	329	if ( ! cdbEntryObject ) return kFALSE;
	330
	331	AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
	332	AliMpDataStreams dataStreams(dataMap);
	333	AliMpManuStore::ReadData(dataStreams);
	334	return kTRUE;
	335	}
	336	else {
	337	AliDebugClassStream(1)
	338	<< "Loading Manu store from MUON/Calib/ManuStore" << endl;
	339
	340	// Load Manu store
	341	TObject* cdbEntryObject = GetCDBEntryObject("MUON/Calib/ManuStore");
	342	return cdbEntryObject != 0x0;
	343	}
	344	}
	345
228fd720	346	//______________________________________________________________________________
	347	Bool_t AliMpCDB::WriteMpData()
	348	{
	349	/// Write mapping data in OCDB
	350
	351	AliCDBManager* cdbManager = AliCDBManager::Instance();
	352	if ( ! cdbManager->GetDefaultStorage() )
162637e4	353	cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
228fd720	354
	355	AliCDBMetaData* cdbData = new AliCDBMetaData();
	356	cdbData->SetResponsible("Dimuon Offline project");
	357	cdbData->SetComment("MUON mapping");
	358	cdbData->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
	359	AliCDBId id("MUON/Calib/MappingData", 0, AliCDBRunRange::Infinity());
	360
	361	AliMpDataProcessor mp;
ab167304	362	AliMpDataMap* map = mp.CreateDataMap("data");
	363	return cdbManager->Put(map, id, cdbData);
	364	}
	365
	366	//______________________________________________________________________________
	367	Bool_t AliMpCDB::WriteMpRunData()
	368	{
	369	/// Write mapping data in OCDB
	370
	371	AliCDBManager* cdbManager = AliCDBManager::Instance();
	372	if ( ! cdbManager->GetDefaultStorage() )
162637e4	373	cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
ab167304	374
	375	AliCDBMetaData* cdbData = new AliCDBMetaData();
	376	cdbData->SetResponsible("Dimuon Offline project");
	377	cdbData->SetComment("MUON run-dependent mapping");
	378	cdbData->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
	379	AliCDBId id("MUON/Calib/MappingRunData", 0, AliCDBRunRange::Infinity());
	380
	381	AliMpDataProcessor mp;
	382	AliMpDataMap* map = mp.CreateDataMap("data_run");
228fd720	383	return cdbManager->Put(map, id, cdbData);
	384	}
	385
3f862c88	386	//______________________________________________________________________________
90bcb4c9	387	Bool_t AliMpCDB::WriteMpSegmentation(Bool_t readData)
3f862c88	388	{
	389	/// Write mapping segmentation in OCDB
	390
90bcb4c9	391	if ( ! readData && ! AliMpSegmentation::Instance() ) return false;
90bcb4c9	392
3f862c88	393	AliCDBManager* cdbManager = AliCDBManager::Instance();
3f862c88	394	if ( ! cdbManager->GetDefaultStorage() )
162637e4	395	cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
3f862c88	396
	397	AliCDBMetaData* cdbData = new AliCDBMetaData();
	398	cdbData->SetResponsible("Dimuon Offline project");
	399	cdbData->SetComment("MUON mapping");
	400	cdbData->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
ebbfcf5c	401	AliCDBId id("MUON/Calib/Mapping", 0, AliCDBRunRange::Infinity());
3f862c88	402
90bcb4c9	403	if ( readData ) {
ab167304	404	AliMpDataStreams dataStreams;
	405	AliMpSegmentation::ReadData(dataStreams, false);
	406	AliMpDDLStore::ReadData(dataStreams, false);
90bcb4c9	407	}
90bcb4c9	408
3f862c88	409	return cdbManager->Put(AliMpSegmentation::Instance(), id, cdbData);
	410	}
	411
	412	//______________________________________________________________________________
90bcb4c9	413	Bool_t AliMpCDB::WriteDDLStore(Bool_t readData)
3f862c88	414	{
	415	/// Write mapping DDL store in OCDB
	416
90bcb4c9	417	if ( ! readData && ! AliMpDDLStore::Instance() ) return false;
90bcb4c9	418
3f862c88	419	AliCDBManager* cdbManager = AliCDBManager::Instance();
3f862c88	420	if ( ! cdbManager->GetDefaultStorage() )
162637e4	421	cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
3f862c88	422
	423	AliCDBMetaData* cdbData = new AliCDBMetaData();
	424	cdbData->SetResponsible("Dimuon Offline project");
	425	cdbData->SetComment("MUON DDL store");
	426	cdbData->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
ebbfcf5c	427	AliCDBId id("MUON/Calib/DDLStore", 0, AliCDBRunRange::Infinity());
3f862c88	428
90bcb4c9	429	if ( readData ) {
ab167304	430	AliMpDataStreams dataStreams;
	431	AliMpSegmentation::ReadData(dataStreams, false);
	432	AliMpDDLStore::ReadData(dataStreams, false);
90bcb4c9	433	}
3f862c88	434	return cdbManager->Put(AliMpDDLStore::Instance(), id, cdbData);
3f862c88	435	}
228fd720	436
ab167304	437	//______________________________________________________________________________
	438	Bool_t AliMpCDB::WriteManuStore(Bool_t readData)
	439	{
	440	/// Write mapping Manu store in OCDB
	441
	442	if ( ! readData && ! AliMpManuStore::Instance() ) return false;
	443
	444	AliCDBManager* cdbManager = AliCDBManager::Instance();
	445	if ( ! cdbManager->GetDefaultStorage() )
162637e4	446	cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
ab167304	447
	448	AliCDBMetaData* cdbData = new AliCDBMetaData();
	449	cdbData->SetResponsible("Dimuon Offline project");
	450	cdbData->SetComment("MUON Manu store");
	451	cdbData->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
	452	AliCDBId id("MUON/Calib/ManuStore", 0, AliCDBRunRange::Infinity());
	453
	454	if ( readData ) {
	455	AliMpDataStreams dataStreams;
	456	AliMpSegmentation::ReadData(dataStreams, false);
	457	AliMpManuStore::ReadData(dataStreams, false);
	458	}
	459	return cdbManager->Put(AliMpManuStore::Instance(), id, cdbData);
	460	}
	461
228fd720	462	//______________________________________________________________________________
	463	Bool_t AliMpCDB::GenerateMpData(const char* cdbpath, Int_t runNumber)
	464	{
	465	/// Generate mapping data ASCII files from OCDB
	466
	467	TObject* cdbEntryObject
	468	= GetCDBEntryObject("MUON/Calib/MappingData", cdbpath, runNumber);
	469	if ( ! cdbEntryObject ) return kFALSE;
	470
	471	AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
	472	AliMpDataProcessor mp;
	473	return mp.GenerateData(dataMap);
	474	}
	475
ab167304	476	//______________________________________________________________________________
	477	Bool_t AliMpCDB::GenerateMpRunData(const char* cdbpath, Int_t runNumber)
	478	{
	479	/// Generate mapping data ASCII files from OCDB
	480
	481	TObject* cdbEntryObject
	482	= GetCDBEntryObject("MUON/Calib/MappingRunData", cdbpath, runNumber);
	483	if ( ! cdbEntryObject ) return kFALSE;
	484
	485	AliMpDataMap* dataMap = (AliMpDataMap*)cdbEntryObject;
	486	AliMpDataProcessor mp;
	487	return mp.GenerateData(dataMap);
	488	}
	489
183279c1	490	//______________________________________________________________________________
	491	void AliMpCDB::UnloadAll()
	492	{
	493	/// Unload all the mapping from the memory
	494	delete AliMpDDLStore::Instance(false);
	495	delete AliMpSegmentation::Instance(false);
	496	delete AliMpDEStore::Instance(false);
	497	}
228fd720	498