[u/mrichter/AliRoot.git] / MUON / AliMUONTrackerIO.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$

#include <cstdlib>
#include <iostream>
#include "AliMUONTrackerIO.h"

/// \class AliMUONTrackerIO
///
/// Reader class for ASCII calibration files for MUON tracker : 
/// converts those ASCII files into AliMUONVStore (suitable to e.g. feed
/// the OCDB).
///
/// \author Laurent Aphecetche, Subatech

using std::ostringstream;
using std::istringstream;
using std::cout;
using std::endl;
/// \cond CLASSIMP
ClassImp(AliMUONTrackerIO)
/// \endcond

#include "AliDCSValue.h"
#include "AliLog.h"
#include "AliMUONCalibParamND.h"
#include "AliMUONCalibParamNF.h"
#include "AliMUONVStore.h"
#include "AliMpConstants.h"
#include "AliMpDDLStore.h"
#include "AliMpDEManager.h"
#include "AliMpDetElement.h"
#include <Riostream.h>
#include <TClass.h>
#include <TObjString.h>
#include <TSystem.h>
#include <sstream>

//_____________________________________________________________________________
AliMUONTrackerIO::AliMUONTrackerIO()
{
  /// ctor
}

//_____________________________________________________________________________
AliMUONTrackerIO::~AliMUONTrackerIO()
{
  /// dtor
}

//_____________________________________________________________________________
Int_t 
AliMUONTrackerIO::ReadOccupancy(const char* filename,AliMUONVStore& occupancyMap)
{
  /// Read occupancy file created by online DA
  /// and append values to the occupancyMap store.
  /// Expected format of the file is :
  /// busPatchId manuId sumofn nevt
  
  TString sFilename(gSystem->ExpandPathName(filename));
  
  std::ifstream in(sFilename.Data());
  if (!in.good()) 
  {
    return kCannotOpenFile;
  }
  
  TString datastring;
  ostringstream stream;
  char line[1024];
  while ( in.getline(line,1024) )
  	stream << line << "\n";
  
  in.close();
  
  return DecodeOccupancy(stream.str().c_str(),occupancyMap);
  
}

//_____________________________________________________________________________
Int_t 
AliMUONTrackerIO::DecodeOccupancy(const char* data, AliMUONVStore& occupancyMap)
{
  /// Decode occupancy string created append values to the occupancyMap store.
  /// Expected format of the file is :
  /// busPatchId manuId sumofn nevt
 
  if ( ! AliMpDDLStore::Instance(kFALSE) )
  {
    AliErrorClass("Mapping not loaded. Cannot work");
    return kNoMapping;
  }
  
  char line[1024];
  istringstream in(data);
  
  Int_t n(0);
  
  while ( in.getline(line,1024) )
  {
    AliDebugClass(3,Form("line=%s",line));
    if ( line[0] == '/' && line[1] == '/' ) continue;
    std::istringstream sin(line);
    
    Int_t busPatchId, manuId;
    Int_t numberOfEvents;
    Double_t sumn;

    sin >> busPatchId >> manuId >> sumn >> numberOfEvents;
    
    if ( busPatchId == -1 && manuId == -1 && sumn == 0 && numberOfEvents == 0 )
    {
      /// DA could not produce information (because run failed somehow). 
      /// That's OK, but let the world know about it
      return kNoInfoFile;
    }
    
    Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromBus(busPatchId);

    AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);

    Int_t numberOfChannelsInManu = -1;
    
    if (de) numberOfChannelsInManu = de->NofChannelsInManu(manuId);

    if ( numberOfChannelsInManu <= 0 ) 
    {
      AliErrorClass(Form("BP %5d DE %5d MANU %5d nchannels=%d",busPatchId,detElemId,manuId,numberOfChannelsInManu));
      continue;      
    }
    
    AliMUONVCalibParam* occupancy = 
    static_cast<AliMUONVCalibParam*>(occupancyMap.FindObject(detElemId,manuId));
    if (occupancy) 
    {
      AliErrorClass(Form("DE %5d MANU %5d is already there ?!",detElemId,manuId));
      continue;
    }
        
    occupancy = new AliMUONCalibParamND(5,1,detElemId,manuId,0);

    occupancyMap.Add(occupancy);
    
    occupancy->SetValueAsDouble(0,0,sumn);
    occupancy->SetValueAsDouble(0,1,sumn); // with only 0 and 1s, sumw = sumw2 = sumn
    occupancy->SetValueAsDouble(0,2,sumn);
    occupancy->SetValueAsInt(0,3,numberOfChannelsInManu);
    occupancy->SetValueAsInt(0,4,numberOfEvents);
    ++n;
  }
  
  return n;
}

//_____________________________________________________________________________
Int_t 
AliMUONTrackerIO::ReadPedestals(const char* filename, AliMUONVStore& pedStore)
{
  /// Read pedestal file (produced by the MUONTRKda.exe program for instance)
  /// and append the read values into the given VStore
  /// To be used when the input is a file (for instance when reading data 
  /// from the OCDB).
  
  TString sFilename(gSystem->ExpandPathName(filename));
  
  std::ifstream in(sFilename.Data());
  if (!in.good()) 
  {
    return kCannotOpenFile;
  }
  
  ostringstream stream;
  char line[1024];
  while ( in.getline(line,1024) )
  	stream << line << "\n";
  
  in.close();

  return DecodePedestals(stream.str().c_str(),pedStore);
  
}

//_____________________________________________________________________________
Int_t 
AliMUONTrackerIO::DecodePedestals(const char* data, AliMUONVStore& pedStore)
{
  /// Read pedestal Data (produced by the MUONTRKda.exe program for instance)
  /// and append the read values into the given VStore
  /// To be used when the input is a TString (for instance when getting data 
  /// from AMORE DB).
  
  char line[1024];
  Int_t busPatchID, manuID, manuChannel;
  Float_t pedMean, pedSigma;
  Int_t n(0);
  istringstream in(data);
  
  while ( in.getline(line,1024) )
  {
    AliDebugClass(3,Form("line=%s",line));
    if ( line[0] == '/' && line[1] == '/' ) continue;
    std::istringstream sin(line);
    sin >> busPatchID >> manuID >> manuChannel >> pedMean >> pedSigma;
    Int_t detElemID = AliMpDDLStore::Instance()->GetDEfromBus(busPatchID);
    
    if ( !AliMpDEManager::IsValidDetElemId(detElemID) )
    {
      AliErrorClass(Form("Got an invalid DE = %d from busPatchId=%d manuId=%d",
                         detElemID,busPatchID,manuID));
      continue;
    }
    
    AliDebugClass(3,Form("BUSPATCH %3d DETELEMID %4d MANU %3d CH %3d MEAN %7.2f SIGMA %7.2f",
                    busPatchID,detElemID,manuID,manuChannel,pedMean,pedSigma));
		    
    AliMUONVCalibParam* ped = 
      static_cast<AliMUONVCalibParam*>(pedStore.FindObject(detElemID,manuID));
    if (!ped) 
    {
      ped = new AliMUONCalibParamNF(2,AliMpConstants::ManuNofChannels(),
                                    detElemID,manuID,
                                    AliMUONVCalibParam::InvalidFloatValue());  
      pedStore.Add(ped);
    }
    ped->SetValueAsFloat(manuChannel,0,pedMean);
    ped->SetValueAsFloat(manuChannel,1,pedSigma);
    ++n;
  }

  return n;
}

//_____________________________________________________________________________
Int_t 
AliMUONTrackerIO::ReadGains(const char* filename, AliMUONVStore& gainStore,
                            TString& comment)
{
  /// Read gain file (produced by the MUONTRKda.exe program for instance)
  /// and append the read values into the given VStore
  /// To be used when the input is a file (for instance when reading data 
  /// from the OCDB).
  
  comment = "";
  
  TString sFilename(gSystem->ExpandPathName(filename));
  
  std::ifstream in(sFilename.Data());
  if (!in.good()) 
  {
    return kCannotOpenFile;
  }
  
  ostringstream stream;
  char line[1024];
  while ( in.getline(line,1024) )
  	stream << line << "\n";
  
  in.close();
  
  return DecodeGains(stream.str().c_str(),gainStore,comment);

}

//_____________________________________________________________________________
Int_t 
AliMUONTrackerIO::DecodeGains(const char* data, AliMUONVStore& gainStore,
                              TString& comment)
{
  /// Read gain file (produced by the MUONTRKda.exe program for instance)
  /// and append the read values into the given VStore
  /// To be used when the input is a string (for instance when getting data 
  /// from AMORE DB).
  
  char line[1024];
  istringstream in(data);
  Int_t busPatchID, manuID, manuChannel;
  Float_t a0, a1;
  Int_t thres;
  UInt_t qual;
  const Int_t kSaturation(3000); // FIXME: how to get this number ?
  Int_t n(0);
  Int_t runNumber(-1);
  Int_t* runs(0x0);
  Int_t* dac(0x0);
  Int_t nDAC(0);
  Int_t nInit(0),f1nbp(0),f2nbp(0);
  
  while ( in.getline(line,1024) )
  {
    if ( strlen(line) < 10 ) continue;
    if ( line[0] == '/' && line[1] == '/' ) 
    {
      TString sline(line);
      if ( sline.Contains("DUMMY") )
      {
        AliDebugClass(1,"Got a dummy file here");
        delete [] runs;
        delete [] dac;
        return kDummyFile;
      }
      if ( sline.Contains("* Run") )
      {
        TObjArray* a = sline.Tokenize(":");
        if ( a->GetLast() >= 1 ) 
        {
          TString s = static_cast<TObjString*>(a->At(1))->String();
          runNumber = s.Atoi();
          AliDebugClass(1,Form("runNumber is %d",runNumber));
        }            
	delete a;
      }
      if ( sline.Contains("DAC values") )
      {
        nDAC = TString(sline(2,sline.Length()-2)).Atoi();
        AliDebugClass(1,Form("# of DAC values = %d",nDAC));
        if ( nDAC > 0 )
        {
          if ( nDAC < 100 ) 
          {
            delete[] runs;
            delete[] dac;
            runs = new Int_t[nDAC];
            dac = new Int_t[nDAC];
            // skip two lines
            in.getline(line,1024);
            sline = line;
            if (!sline.Contains("*  nInit ="))
            {
              AliErrorClass("Improper format : was expecting nInit= line...");              
            }
            else
            {
              sscanf(line,"//   *  nInit = %d  *  f1nbp = %d  *  f2nbp = %d",&nInit,&f1nbp,&f2nbp);
              AliDebugClass(1,Form("nInit = %d",nInit));
              AliDebugClass(1,Form("f1nbp = %d",f1nbp));
              AliDebugClass(1,Form("f2nbp = %d",f2nbp));
            }
            in.getline(line,1024);
            in.getline(line,1024);
            // then get run and dac values
            Int_t iDAC(0);
            for ( Int_t i = 0; i < nDAC; ++i ) 
            {
              in.getline(line,1024);
              Int_t a,b;
              sscanf(line,"// %d %d",&a,&b);
              runs[iDAC] = a;
              dac[iDAC] = b;
              AliDebugClass(1,Form("RUN %d is DAC %d",runs[iDAC],dac[iDAC]));
              ++iDAC;
            }
          }
          else
          {
            AliErrorClass(Form("Something went wrong, as I get too big nDAC = %d",nDAC));
            nDAC = 0;
            delete [] runs;
            delete [] dac;
            return kFormatError;
          }
        }
      }
      continue;
    }
    
    sscanf(line,"%d %d %d %f %f %d %x",&busPatchID,&manuID,&manuChannel,
           &a0,&a1,&thres,&qual); 
    AliDebugClass(3,Form("line=%s",line));
    Int_t detElemID = AliMpDDLStore::Instance()->GetDEfromBus(busPatchID);
    
    if ( !AliMpDEManager::IsValidDetElemId(detElemID) )
    {
      AliErrorClass(Form("Got an invalid DE = %d from busPatchId=%d manuId=%d",
                         detElemID,busPatchID,manuID));
      continue;
    }
    
    AliDebugClass(3,Form("BUSPATCH %3d DETELEMID %4d MANU %3d CH %3d A0 %7.2f "
                    "A1 %e THRES %5d QUAL %x",
                    busPatchID,detElemID,manuID,manuChannel,a0,a1,thres,qual));
    if ( qual == 0 ) continue;
    
    AliMUONVCalibParam* gain = 
      static_cast<AliMUONVCalibParam*>(gainStore.FindObject(detElemID,manuID));
    
   if (!gain) 
    {
      gain = new AliMUONCalibParamNF(5,AliMpConstants::ManuNofChannels(),detElemID,manuID,0);
      gainStore.Add(gain);
    }
    gain->SetValueAsFloat(manuChannel,0,a0);
    gain->SetValueAsFloat(manuChannel,1,a1);
    gain->SetValueAsInt(manuChannel,2,thres);
    gain->SetValueAsInt(manuChannel,3,qual);
    gain->SetValueAsInt(manuChannel,4,kSaturation);
    ++n;
  }

  comment = "";
  
  if ( runNumber > 0 )
  {
    comment = Form("RUN %d",runNumber);
  }
  
  for ( Int_t i = 0; i < nDAC; ++i )
  {
    comment += Form(";(RUN %d = DAC %d)",runs[i],dac[i]);
  }
  comment += Form(";(nDAC = %d)",nDAC);
  comment += Form(";(nInit = %d)",nInit);
  comment += Form(";(f1nbp = %d)",f1nbp);
  comment += Form(";(f2nbp = %d)",f2nbp);
  
  delete[] runs;
  delete[] dac;
  
  return n;
}

//_____________________________________________________________________________
Int_t
AliMUONTrackerIO::ReadCapacitances(const char* filename, AliMUONVStore& capaStore)
{
  /// Read capacitance file
  /// and append the read values into the given VStore
  
  TString sFilename(gSystem->ExpandPathName(filename));
  
  std::ifstream in(sFilename.Data());
  if (!in.good()) 
  {
    return kCannotOpenFile;
  }
  
  ostringstream stream;
  char line[1024];
  while ( in.getline(line,1024) )
  	stream << line << "\n";
  
  in.close();
  
  return DecodeCapacitances(stream.str().c_str(),capaStore);
}

//_____________________________________________________________________________
Int_t
AliMUONTrackerIO::DecodeCapacitances(const char* data, AliMUONVStore& capaStore)
{
  /// Read capacitances and append the read values into the given VStore
  /// To be used when the input is a string (for instance when getting data 
  /// from AMORE DB).
  
  Int_t ngenerated(0);
  
  char line[1024];
  Int_t serialNumber(-1);
  AliMUONVCalibParam* param(0x0);
  istringstream in(data);

  while ( in.getline(line,1024,'\n') )
  {
    if ( isdigit(line[0]) ) 
    {
      serialNumber = atoi(line);
      param = static_cast<AliMUONVCalibParam*>(capaStore.FindObject(serialNumber));
      if (param)
      {
        AliErrorClass(Form("serialNumber %d appears several times !",serialNumber));
        continue;
      }
      param = new AliMUONCalibParamNF(2,AliMpConstants::ManuNofChannels(),serialNumber,0,1.0);
      Bool_t ok = capaStore.Add(param);
      if (!ok)
      {
        AliErrorClass(Form("Could not set serialNumber=%d",serialNumber));
        continue;
      }      
      continue;
    }
    
    if (!param) continue;
    
    Int_t channel;
    Float_t capaValue;
    Float_t injectionGain;
    sscanf(line,"%d %f %f",&channel,&capaValue,&injectionGain);
    AliDebugClass(1,Form("SerialNumber %10d Channel %3d Capa %f injectionGain %f",
                    serialNumber,channel,capaValue,injectionGain));
    param->SetValueAsFloat(channel,0,capaValue);
    param->SetValueAsFloat(channel,1,injectionGain);
    ++ngenerated;
  }
  
  return ngenerated;
}

//_____________________________________________________________________________
Int_t 
AliMUONTrackerIO::ReadConfig(const char* filename, AliMUONVStore& confStore)
{
  /// Read config file (produced by the MUONTRKda.exe program for instance)
  /// and append the read values into the given VStore
  /// To be used when the input is a file (for instance when reading data 
  /// from the OCDB).
  
  TString sFilename(gSystem->ExpandPathName(filename));
  
  std::ifstream in(sFilename.Data());
  if (!in.good()) 
  {
    return kCannotOpenFile;
  }
  
  ostringstream stream;
  char line[1024];
  while ( in.getline(line,1024) )
  	stream << line << "\n";
  
  in.close();
  
  return DecodeConfig(stream.str().c_str(),confStore);
}

//_____________________________________________________________________________
Int_t 
AliMUONTrackerIO::DecodeConfig(const char* data, AliMUONVStore& confStore)
{
  /// Read config data (produced by the MUONTRKda.exe program for instance)
  /// and append the read values into the given VStore
  /// To be used when the input is a TString (for instance when getting data 
  /// from AMORE DB).

  char line[1024];
  Int_t busPatchID, manuID;
  Int_t n(0);
  istringstream in(data);
  
  while ( in.getline(line,1024) )
  {
    AliDebugClass(3,Form("line=%s",line));
    if ( line[0] == '#' ) 
    {
      continue;
    }
    std::istringstream sin(line);
    sin >> busPatchID >> manuID;

    Int_t detElemID = AliMpDDLStore::Instance()->GetDEfromBus(busPatchID);

    if ( !AliMpDEManager::IsValidDetElemId(detElemID) )
    {
      AliErrorClass(Form("Got an invalid DE = %d from busPatchId=%d manuId=%d",
                         detElemID,busPatchID,manuID));
      continue;
    }
    
    AliMUONVCalibParam* conf = 
    static_cast<AliMUONVCalibParam*>(confStore.FindObject(detElemID,manuID));
    if (!conf) 
    {
      conf = new AliMUONCalibParamNF(1,1,detElemID,manuID,1);
      confStore.Add(conf);
    }
    ++n;
  }
  
  return n;
}

//_____________________________________________________________________________
Int_t 
AliMUONTrackerIO::WriteConfig(ofstream& out, const AliMUONVStore& confStore)
{
  /// Write the conf store as an ASCII file
  /// Note that we are converting (back) the detElemId into a busPatchId
  /// Return the number of lines written
  
  if ( !AliMpDDLStore::Instance() ) 
  {
    cout << "ERROR: mapping not loaded. Cannot work" << endl;
    return 0;
  }
  
  TIter next(confStore.CreateIterator());
  AliMUONVCalibParam* param;
  Int_t n(0);
  
  while ( (param=static_cast<AliMUONVCalibParam*>(next())) )
  {
    Int_t detElemId = param->ID0();
    Int_t manuId = param->ID1();
    
    Int_t busPatchId = AliMpDDLStore::Instance()->GetBusPatchId(detElemId,manuId);
    ++n;
    
    out << busPatchId << " " << manuId << endl;
  }
  return n;
}
Commit	Line	Data
81028269	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
b09247a2	18	#include <cstdlib>
b80faac0	19	#include <iostream>
81028269	20	#include "AliMUONTrackerIO.h"
	21
	22	/// \class AliMUONTrackerIO
	23	///
	24	/// Reader class for ASCII calibration files for MUON tracker :
	25	/// converts those ASCII files into AliMUONVStore (suitable to e.g. feed
	26	/// the OCDB).
	27	///
	28	/// \author Laurent Aphecetche, Subatech
	29
b80faac0	30	using std::ostringstream;
	31	using std::istringstream;
	32	using std::cout;
	33	using std::endl;
81028269	34	/// \cond CLASSIMP
	35	ClassImp(AliMUONTrackerIO)
	36	/// \endcond
	37
6c870207	38	#include "AliDCSValue.h"
81028269	39	#include "AliLog.h"
7eafe398	40	#include "AliMUONCalibParamND.h"
81028269	41	#include "AliMUONCalibParamNF.h"
	42	#include "AliMUONVStore.h"
	43	#include "AliMpConstants.h"
	44	#include "AliMpDDLStore.h"
6c870207	45	#include "AliMpDEManager.h"
7eafe398	46	#include "AliMpDetElement.h"
81028269	47	#include <Riostream.h>
	48	#include <TClass.h>
	49	#include <TObjString.h>
	50	#include <TSystem.h>
	51	#include <sstream>
	52
	53	//_____________________________________________________________________________
	54	AliMUONTrackerIO::AliMUONTrackerIO()
	55	{
	56	/// ctor
	57	}
	58
	59	//_____________________________________________________________________________
	60	AliMUONTrackerIO::~AliMUONTrackerIO()
	61	{
	62	/// dtor
	63	}
	64
7eafe398	65	//_____________________________________________________________________________
	66	Int_t
	67	AliMUONTrackerIO::ReadOccupancy(const char* filename,AliMUONVStore& occupancyMap)
	68	{
	69	/// Read occupancy file created by online DA
	70	/// and append values to the occupancyMap store.
	71	/// Expected format of the file is :
	72	/// busPatchId manuId sumofn nevt
	73
	74	TString sFilename(gSystem->ExpandPathName(filename));
	75
	76	std::ifstream in(sFilename.Data());
	77	if (!in.good())
	78	{
	79	return kCannotOpenFile;
	80	}
	81
	82	TString datastring;
	83	ostringstream stream;
	84	char line[1024];
	85	while ( in.getline(line,1024) )
	86	stream << line << "\n";
7eafe398	87
	88	in.close();
	89
ca913045	90	return DecodeOccupancy(stream.str().c_str(),occupancyMap);
7eafe398	91
	92	}
	93
	94	//_____________________________________________________________________________
	95	Int_t
ca913045	96	AliMUONTrackerIO::DecodeOccupancy(const char* data, AliMUONVStore& occupancyMap)
7eafe398	97	{
	98	/// Decode occupancy string created append values to the occupancyMap store.
	99	/// Expected format of the file is :
	100	/// busPatchId manuId sumofn nevt
	101
	102	if ( ! AliMpDDLStore::Instance(kFALSE) )
	103	{
	104	AliErrorClass("Mapping not loaded. Cannot work");
33d94e07	105	return kNoMapping;
7eafe398	106	}
	107
	108	char line[1024];
ca913045	109	istringstream in(data);
7eafe398	110
	111	Int_t n(0);
	112
	113	while ( in.getline(line,1024) )
	114	{
	115	AliDebugClass(3,Form("line=%s",line));
	116	if ( line[0] == '/' && line[1] == '/' ) continue;
	117	std::istringstream sin(line);
	118
	119	Int_t busPatchId, manuId;
	120	Int_t numberOfEvents;
	121	Double_t sumn;
	122
	123	sin >> busPatchId >> manuId >> sumn >> numberOfEvents;
	124
33d94e07	125	if ( busPatchId == -1 && manuId == -1 && sumn == 0 && numberOfEvents == 0 )
	126	{
	127	/// DA could not produce information (because run failed somehow).
	128	/// That's OK, but let the world know about it
	129	return kNoInfoFile;
	130	}
	131
7eafe398	132	Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromBus(busPatchId);
	133
	134	AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
	135
	136	Int_t numberOfChannelsInManu = -1;
	137
	138	if (de) numberOfChannelsInManu = de->NofChannelsInManu(manuId);
	139
	140	if ( numberOfChannelsInManu <= 0 )
	141	{
	142	AliErrorClass(Form("BP %5d DE %5d MANU %5d nchannels=%d",busPatchId,detElemId,manuId,numberOfChannelsInManu));
	143	continue;
	144	}
	145
	146	AliMUONVCalibParam* occupancy =
	147	static_cast<AliMUONVCalibParam*>(occupancyMap.FindObject(detElemId,manuId));
	148	if (occupancy)
	149	{
	150	AliErrorClass(Form("DE %5d MANU %5d is already there ?!",detElemId,manuId));
	151	continue;
	152	}
	153
	154	occupancy = new AliMUONCalibParamND(5,1,detElemId,manuId,0);
	155
	156	occupancyMap.Add(occupancy);
	157
	158	occupancy->SetValueAsDouble(0,0,sumn);
	159	occupancy->SetValueAsDouble(0,1,sumn); // with only 0 and 1s, sumw = sumw2 = sumn
	160	occupancy->SetValueAsDouble(0,2,sumn);
	161	occupancy->SetValueAsInt(0,3,numberOfChannelsInManu);
	162	occupancy->SetValueAsInt(0,4,numberOfEvents);
	163	++n;
	164	}
	165
	166	return n;
	167	}
	168
81028269	169	//_____________________________________________________________________________
	170	Int_t
	171	AliMUONTrackerIO::ReadPedestals(const char* filename, AliMUONVStore& pedStore)
	172	{
	173	/// Read pedestal file (produced by the MUONTRKda.exe program for instance)
	174	/// and append the read values into the given VStore
cba13f7c	175	/// To be used when the input is a file (for instance when reading data
cba13f7c	176	/// from the OCDB).
81028269	177
	178	TString sFilename(gSystem->ExpandPathName(filename));
	179
	180	std::ifstream in(sFilename.Data());
	181	if (!in.good())
	182	{
	183	return kCannotOpenFile;
	184	}
	185
06a51226	186	ostringstream stream;
	187	char line[1024];
	188	while ( in.getline(line,1024) )
	189	stream << line << "\n";
06a51226	190
cba13f7c	191	in.close();
cba13f7c	192
ca913045	193	return DecodePedestals(stream.str().c_str(),pedStore);
cba13f7c	194
	195	}
	196
	197	//_____________________________________________________________________________
	198	Int_t
ca913045	199	AliMUONTrackerIO::DecodePedestals(const char* data, AliMUONVStore& pedStore)
cba13f7c	200	{
	201	/// Read pedestal Data (produced by the MUONTRKda.exe program for instance)
	202	/// and append the read values into the given VStore
	203	/// To be used when the input is a TString (for instance when getting data
	204	/// from AMORE DB).
	205
81028269	206	char line[1024];
	207	Int_t busPatchID, manuID, manuChannel;
	208	Float_t pedMean, pedSigma;
	209	Int_t n(0);
ca913045	210	istringstream in(data);
81028269	211
	212	while ( in.getline(line,1024) )
	213	{
	214	AliDebugClass(3,Form("line=%s",line));
	215	if ( line[0] == '/' && line[1] == '/' ) continue;
	216	std::istringstream sin(line);
	217	sin >> busPatchID >> manuID >> manuChannel >> pedMean >> pedSigma;
	218	Int_t detElemID = AliMpDDLStore::Instance()->GetDEfromBus(busPatchID);
6c870207	219
	220	if ( !AliMpDEManager::IsValidDetElemId(detElemID) )
	221	{
	222	AliErrorClass(Form("Got an invalid DE = %d from busPatchId=%d manuId=%d",
	223	detElemID,busPatchID,manuID));
	224	continue;
	225	}
	226
81028269	227	AliDebugClass(3,Form("BUSPATCH %3d DETELEMID %4d MANU %3d CH %3d MEAN %7.2f SIGMA %7.2f",
81028269	228	busPatchID,detElemID,manuID,manuChannel,pedMean,pedSigma));
cba13f7c	229
81028269	230	AliMUONVCalibParam* ped =
81028269	231	static_cast<AliMUONVCalibParam*>(pedStore.FindObject(detElemID,manuID));
81028269	232	if (!ped)
	233	{
	234	ped = new AliMUONCalibParamNF(2,AliMpConstants::ManuNofChannels(),
	235	detElemID,manuID,
	236	AliMUONVCalibParam::InvalidFloatValue());
	237	pedStore.Add(ped);
	238	}
	239	ped->SetValueAsFloat(manuChannel,0,pedMean);
	240	ped->SetValueAsFloat(manuChannel,1,pedSigma);
	241	++n;
	242	}
81028269	243
	244	return n;
	245	}
	246
	247	//_____________________________________________________________________________
	248	Int_t
	249	AliMUONTrackerIO::ReadGains(const char* filename, AliMUONVStore& gainStore,
	250	TString& comment)
	251	{
	252	/// Read gain file (produced by the MUONTRKda.exe program for instance)
	253	/// and append the read values into the given VStore
cba13f7c	254	/// To be used when the input is a file (for instance when reading data
cba13f7c	255	/// from the OCDB).
81028269	256
	257	comment = "";
	258
	259	TString sFilename(gSystem->ExpandPathName(filename));
	260
	261	std::ifstream in(sFilename.Data());
	262	if (!in.good())
	263	{
	264	return kCannotOpenFile;
	265	}
	266
cba13f7c	267	ostringstream stream;
	268	char line[1024];
	269	while ( in.getline(line,1024) )
	270	stream << line << "\n";
cba13f7c	271
	272	in.close();
	273
ca913045	274	return DecodeGains(stream.str().c_str(),gainStore,comment);
cba13f7c	275
	276	}
	277
	278	//_____________________________________________________________________________
	279	Int_t
ca913045	280	AliMUONTrackerIO::DecodeGains(const char* data, AliMUONVStore& gainStore,
ca913045	281	TString& comment)
cba13f7c	282	{
	283	/// Read gain file (produced by the MUONTRKda.exe program for instance)
	284	/// and append the read values into the given VStore
ca913045	285	/// To be used when the input is a string (for instance when getting data
cba13f7c	286	/// from AMORE DB).
cba13f7c	287
81028269	288	char line[1024];
ca913045	289	istringstream in(data);
81028269	290	Int_t busPatchID, manuID, manuChannel;
	291	Float_t a0, a1;
	292	Int_t thres;
	293	UInt_t qual;
	294	const Int_t kSaturation(3000); // FIXME: how to get this number ?
	295	Int_t n(0);
	296	Int_t runNumber(-1);
	297	Int_t* runs(0x0);
	298	Int_t* dac(0x0);
	299	Int_t nDAC(0);
1ccd531d	300	Int_t nInit(0),f1nbp(0),f2nbp(0);
81028269	301
	302	while ( in.getline(line,1024) )
	303	{
	304	if ( strlen(line) < 10 ) continue;
	305	if ( line[0] == '/' && line[1] == '/' )
	306	{
	307	TString sline(line);
	308	if ( sline.Contains("DUMMY") )
	309	{
	310	AliDebugClass(1,"Got a dummy file here");
7ae72085	311	delete [] runs;
7ae72085	312	delete [] dac;
81028269	313	return kDummyFile;
	314	}
	315	if ( sline.Contains("* Run") )
	316	{
	317	TObjArray* a = sline.Tokenize(":");
	318	if ( a->GetLast() >= 1 )
	319	{
	320	TString s = static_cast<TObjString*>(a->At(1))->String();
	321	runNumber = s.Atoi();
	322	AliDebugClass(1,Form("runNumber is %d",runNumber));
	323	}
09d5920f	324	delete a;
81028269	325	}
	326	if ( sline.Contains("DAC values") )
	327	{
	328	nDAC = TString(sline(2,sline.Length()-2)).Atoi();
	329	AliDebugClass(1,Form("# of DAC values = %d",nDAC));
	330	if ( nDAC > 0 )
	331	{
	332	if ( nDAC < 100 )
	333	{
31244123	334	delete[] runs;
31244123	335	delete[] dac;
81028269	336	runs = new Int_t[nDAC];
	337	dac = new Int_t[nDAC];
	338	// skip two lines
	339	in.getline(line,1024);
18ec51a0	340	sline = line;
	341	if (!sline.Contains("* nInit ="))
	342	{
	343	AliErrorClass("Improper format : was expecting nInit= line...");
	344	}
	345	else
	346	{
	347	sscanf(line,"// * nInit = %d * f1nbp = %d * f2nbp = %d",&nInit,&f1nbp,&f2nbp);
	348	AliDebugClass(1,Form("nInit = %d",nInit));
	349	AliDebugClass(1,Form("f1nbp = %d",f1nbp));
	350	AliDebugClass(1,Form("f2nbp = %d",f2nbp));
	351	}
	352	in.getline(line,1024);
81028269	353	in.getline(line,1024);
81028269	354	// then get run and dac values
ca913045	355	Int_t iDAC(0);
81028269	356	for ( Int_t i = 0; i < nDAC; ++i )
	357	{
	358	in.getline(line,1024);
	359	Int_t a,b;
	360	sscanf(line,"// %d %d",&a,&b);
	361	runs[iDAC] = a;
	362	dac[iDAC] = b;
	363	AliDebugClass(1,Form("RUN %d is DAC %d",runs[iDAC],dac[iDAC]));
	364	++iDAC;
	365	}
	366	}
	367	else
	368	{
	369	AliErrorClass(Form("Something went wrong, as I get too big nDAC = %d",nDAC));
	370	nDAC = 0;
7ae72085	371	delete [] runs;
7ae72085	372	delete [] dac;
81028269	373	return kFormatError;
	374	}
	375	}
	376	}
	377	continue;
	378	}
	379
	380	sscanf(line,"%d %d %d %f %f %d %x",&busPatchID,&manuID,&manuChannel,
	381	&a0,&a1,&thres,&qual);
	382	AliDebugClass(3,Form("line=%s",line));
	383	Int_t detElemID = AliMpDDLStore::Instance()->GetDEfromBus(busPatchID);
6c870207	384
	385	if ( !AliMpDEManager::IsValidDetElemId(detElemID) )
	386	{
	387	AliErrorClass(Form("Got an invalid DE = %d from busPatchId=%d manuId=%d",
	388	detElemID,busPatchID,manuID));
	389	continue;
	390	}
	391
81028269	392	AliDebugClass(3,Form("BUSPATCH %3d DETELEMID %4d MANU %3d CH %3d A0 %7.2f "
	393	"A1 %e THRES %5d QUAL %x",
	394	busPatchID,detElemID,manuID,manuChannel,a0,a1,thres,qual));
	395	if ( qual == 0 ) continue;
	396
	397	AliMUONVCalibParam* gain =
	398	static_cast<AliMUONVCalibParam*>(gainStore.FindObject(detElemID,manuID));
	399
cba13f7c	400	if (!gain)
81028269	401	{
	402	gain = new AliMUONCalibParamNF(5,AliMpConstants::ManuNofChannels(),detElemID,manuID,0);
	403	gainStore.Add(gain);
	404	}
	405	gain->SetValueAsFloat(manuChannel,0,a0);
	406	gain->SetValueAsFloat(manuChannel,1,a1);
	407	gain->SetValueAsInt(manuChannel,2,thres);
	408	gain->SetValueAsInt(manuChannel,3,qual);
	409	gain->SetValueAsInt(manuChannel,4,kSaturation);
	410	++n;
	411	}
cba13f7c	412
81028269	413	comment = "";
	414
	415	if ( runNumber > 0 )
	416	{
	417	comment = Form("RUN %d",runNumber);
	418	}
	419
	420	for ( Int_t i = 0; i < nDAC; ++i )
	421	{
	422	comment += Form(";(RUN %d = DAC %d)",runs[i],dac[i]);
	423	}
1ccd531d	424	comment += Form(";(nDAC = %d)",nDAC);
	425	comment += Form(";(nInit = %d)",nInit);
	426	comment += Form(";(f1nbp = %d)",f1nbp);
	427	comment += Form(";(f2nbp = %d)",f2nbp);
81028269	428
	429	delete[] runs;
	430	delete[] dac;
	431
	432	return n;
	433	}
	434
	435	//_____________________________________________________________________________
	436	Int_t
ca913045	437	AliMUONTrackerIO::ReadCapacitances(const char* filename, AliMUONVStore& capaStore)
81028269	438	{
	439	/// Read capacitance file
	440	/// and append the read values into the given VStore
	441
ca913045	442	TString sFilename(gSystem->ExpandPathName(filename));
	443
	444	std::ifstream in(sFilename.Data());
	445	if (!in.good())
	446	{
	447	return kCannotOpenFile;
	448	}
	449
	450	ostringstream stream;
	451	char line[1024];
	452	while ( in.getline(line,1024) )
	453	stream << line << "\n";
	454
	455	in.close();
	456
	457	return DecodeCapacitances(stream.str().c_str(),capaStore);
	458	}
	459
	460	//_____________________________________________________________________________
	461	Int_t
	462	AliMUONTrackerIO::DecodeCapacitances(const char* data, AliMUONVStore& capaStore)
	463	{
	464	/// Read capacitances and append the read values into the given VStore
	465	/// To be used when the input is a string (for instance when getting data
	466	/// from AMORE DB).
81028269	467
	468	Int_t ngenerated(0);
	469
	470	char line[1024];
	471	Int_t serialNumber(-1);
	472	AliMUONVCalibParam* param(0x0);
ca913045	473	istringstream in(data);
ca913045	474
81028269	475	while ( in.getline(line,1024,'\n') )
	476	{
	477	if ( isdigit(line[0]) )
	478	{
	479	serialNumber = atoi(line);
	480	param = static_cast<AliMUONVCalibParam*>(capaStore.FindObject(serialNumber));
	481	if (param)
	482	{
	483	AliErrorClass(Form("serialNumber %d appears several times !",serialNumber));
630711ed	484	continue;
81028269	485	}
	486	param = new AliMUONCalibParamNF(2,AliMpConstants::ManuNofChannels(),serialNumber,0,1.0);
	487	Bool_t ok = capaStore.Add(param);
	488	if (!ok)
	489	{
	490	AliErrorClass(Form("Could not set serialNumber=%d",serialNumber));
	491	continue;
	492	}
	493	continue;
	494	}
9b780418	495
	496	if (!param) continue;
	497
81028269	498	Int_t channel;
	499	Float_t capaValue;
	500	Float_t injectionGain;
	501	sscanf(line,"%d %f %f",&channel,&capaValue,&injectionGain);
	502	AliDebugClass(1,Form("SerialNumber %10d Channel %3d Capa %f injectionGain %f",
	503	serialNumber,channel,capaValue,injectionGain));
	504	param->SetValueAsFloat(channel,0,capaValue);
	505	param->SetValueAsFloat(channel,1,injectionGain);
	506	++ngenerated;
	507	}
	508
81028269	509	return ngenerated;
81028269	510	}
6c870207	511
	512	//_____________________________________________________________________________
	513	Int_t
042cd64e	514	AliMUONTrackerIO::ReadConfig(const char* filename, AliMUONVStore& confStore)
6c870207	515	{
	516	/// Read config file (produced by the MUONTRKda.exe program for instance)
	517	/// and append the read values into the given VStore
	518	/// To be used when the input is a file (for instance when reading data
	519	/// from the OCDB).
6c870207	520
	521	TString sFilename(gSystem->ExpandPathName(filename));
	522
	523	std::ifstream in(sFilename.Data());
	524	if (!in.good())
	525	{
	526	return kCannotOpenFile;
	527	}
	528
6c870207	529	ostringstream stream;
	530	char line[1024];
	531	while ( in.getline(line,1024) )
	532	stream << line << "\n";
6c870207	533
	534	in.close();
	535
042cd64e	536	return DecodeConfig(stream.str().c_str(),confStore);
6c870207	537	}
	538
	539	//_____________________________________________________________________________
	540	Int_t
042cd64e	541	AliMUONTrackerIO::DecodeConfig(const char* data, AliMUONVStore& confStore)
6c870207	542	{
	543	/// Read config data (produced by the MUONTRKda.exe program for instance)
	544	/// and append the read values into the given VStore
	545	/// To be used when the input is a TString (for instance when getting data
	546	/// from AMORE DB).
6c870207	547
	548	char line[1024];
	549	Int_t busPatchID, manuID;
	550	Int_t n(0);
ca913045	551	istringstream in(data);
6c870207	552
	553	while ( in.getline(line,1024) )
	554	{
	555	AliDebugClass(3,Form("line=%s",line));
	556	if ( line[0] == '#' )
	557	{
6c870207	558	continue;
	559	}
	560	std::istringstream sin(line);
	561	sin >> busPatchID >> manuID;
	562
	563	Int_t detElemID = AliMpDDLStore::Instance()->GetDEfromBus(busPatchID);
	564
	565	if ( !AliMpDEManager::IsValidDetElemId(detElemID) )
	566	{
	567	AliErrorClass(Form("Got an invalid DE = %d from busPatchId=%d manuId=%d",
	568	detElemID,busPatchID,manuID));
	569	continue;
	570	}
	571
	572	AliMUONVCalibParam* conf =
	573	static_cast<AliMUONVCalibParam*>(confStore.FindObject(detElemID,manuID));
	574	if (!conf)
	575	{
	576	conf = new AliMUONCalibParamNF(1,1,detElemID,manuID,1);
	577	confStore.Add(conf);
	578	}
	579	++n;
	580	}
	581
	582	return n;
	583	}
	584
	585	//_____________________________________________________________________________
	586	Int_t
ca913045	587	AliMUONTrackerIO::WriteConfig(ofstream& out, const AliMUONVStore& confStore)
6c870207	588	{
	589	/// Write the conf store as an ASCII file
	590	/// Note that we are converting (back) the detElemId into a busPatchId
	591	/// Return the number of lines written
	592
	593	if ( !AliMpDDLStore::Instance() )
	594	{
	595	cout << "ERROR: mapping not loaded. Cannot work" << endl;
	596	return 0;
	597	}
	598
	599	TIter next(confStore.CreateIterator());
	600	AliMUONVCalibParam* param;
	601	Int_t n(0);
	602
	603	while ( (param=static_cast<AliMUONVCalibParam*>(next())) )
	604	{
	605	Int_t detElemId = param->ID0();
	606	Int_t manuId = param->ID1();
	607
	608	Int_t busPatchId = AliMpDDLStore::Instance()->GetBusPatchId(detElemId,manuId);
	609	++n;
	610
	611	out << busPatchId << " " << manuId << endl;
	612	}
	613	return n;
	614	}
	615