[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 "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

/// \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 0;
  }
  
  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;
    
    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);
  
  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");
        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));
        }            
      }
      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 ) 
          {
            runs = new Int_t[nDAC];
            dac = new Int_t[nDAC];
            // skip two lines
            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;
            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]);
  }
  
  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;
    }
    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, Bool_t& changed)
{
  /// 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).
  /// changed must be set to kFALSE before calling this method for the first time
  /// (then the subsequent calls must not set it !)
  ///
  
  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,changed);
}

//_____________________________________________________________________________
Int_t 
AliMUONTrackerIO::DecodeConfig(const char* data, AliMUONVStore& confStore, Bool_t& changed)
{
  /// 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).
  /// changed must be set to kFALSE before calling this method for the first time
  /// (then the subsequent calls must not set it !)

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