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

///
/// \class AliMUONRejectList
///
/// Object to hold the probability to reject elements during reconstruction.
///
/// Those elements are either channels, manus, 
/// bus patches, detection elements, or all the four.
/// (we do not consider the next level, chamber, because if a full
/// chamber is missing, we assume we'll remove that run from the
/// list of usable runs anyway).
/// 
/// The probability of rejection can be different from 0.0 or 1.0 only for
/// simulations, in which case it means that :
/// - this object was created from inspection of real data occupancy maps + ad-hoc rejections over
/// several runs
/// - the probability then reflects the chance a given element was useable
/// during data taking. For instance, if one DE has a probability of 0.8, it means
/// it was on (or correctly behaving during data taking) only for 20% of the
/// events.
///
/// \author Laurent Aphecetche, Subatech
///

#include "AliMUONRejectList.h"

#include "AliMpConstants.h"
#include "AliMUON2DMap.h"
#include "AliMUONCalibParamNF.h"
#include "Riostream.h"
#include "TMath.h"

using std::cout;
using std::endl;
/// \cond CLASSIMP
ClassImp(AliMUONRejectList)
/// \endcond

namespace
{
  /// The functions below are here to help re-invent the wheel,
  /// i.e. code something which acts as std::map<int,float>
  /// to circumvent the fact that AliRoot does not allow STL to be used.
  
  void Dump(const char* str, UInt_t n, UInt_t* ids, Float_t* values, Bool_t debug)
  {
    /// Dump the values array
    
    TString s(str);
    s += " PROBA %e";

    for ( UInt_t i = 0; i < n; ++i )
    {
      UInt_t key = ids[i];
      Int_t a,b;
      AliMUONVCalibParam::DecodeUniqueID(key,a,b);
      if ( s.CountChar('%')==3 )
      {
        cout << Form(s.Data(),a,b,values[i]) << endl;
      }
      else
      {
        cout << Form(s.Data(),a,values[i]) << endl;
      }
    }
    
    if ( debug ) 
    {
      cout << "------" << endl;
      for ( UInt_t i = 0; i < n; ++i )
      {
        UInt_t key = ids[i];
        Int_t a,b;
        AliMUONVCalibParam::DecodeUniqueID(key,a,b);
        cout << Form("ids[%5d]=%d values[%5d]=%e (a,b)=(%5d,%5d)",
        i,ids[i],i,values[i],a,b) << endl;
      }
      
    }
  }
  
  Float_t GetValue(UInt_t n, UInt_t* ids, Float_t* values, UInt_t key)
  {
    /// Get the value corresponding to key, or zero if not found
    Long64_t index = TMath::BinarySearch(n,ids,key);

    Bool_t found = ( ( index >= 0 ) && ( ids[index] == key ) );

    if ( found )
    {
      return values[index];
    }
    else
    {
      return 0.0;
    }
  }
  
  void Insert(UInt_t n, UInt_t* ids, Float_t* values, UInt_t index, UInt_t key, Float_t value)
  {
    /// Insert (key,value) into arrays ids and values.
    
    for ( UInt_t i = n; i > index; --i )
    {
      ids[i] = ids[i-1];
      values[i] = values[i-1];
    }
    ids[index] = key;
    values[index] = value;
  }
  
  Bool_t SetValue(UInt_t n, UInt_t* ids, Float_t* values, UInt_t key, Float_t value)
  {
    /// Set the value for a given key
    Long64_t index = TMath::BinarySearch(n,ids, key);

    Bool_t alreadyThere = ( ( index >= 0 ) && ( ids[index] == key ) );

    if ( alreadyThere )
    {
      // replacement
      values[index] = value;
      return kFALSE;
    }
    Insert(n,ids,values,index+1,key,value);
    return kTRUE;
  }
  
  void Copy(UInt_t n, UInt_t* src, UInt_t*& dest)
  {
    /// Copy src into dest
    delete[] dest;
    dest = 0;
    if ( src && n )
    {
      dest = new UInt_t[n];
      memcpy(dest,src,n*sizeof(UInt_t));
    }
  }

  void Copy(UInt_t n, Float_t* src, Float_t*& dest)
  {
    /// Copy src into dest
    delete[] dest;
    dest = 0;
    if ( src && n )
    {
      dest = new Float_t[n];
      memcpy(dest,src,n*sizeof(Float_t));
    }
  }
  
}
    
//_____________________________________________________________________________
AliMUONRejectList::AliMUONRejectList()
: TObject(),
fIsBinary(kTRUE),
fMaxNofDEs(156), // not nice to put a constant here, but that way this object does not need the mapping at creation time...
fMaxNofBPs(888), // same remark as above
fMaxNofManus(16828), // same as above...
fNofDEs(),
fNofBPs(),
fNofManus(),
fDEIds(new UInt_t[fMaxNofDEs]),
fDEProbas(new Float_t[fMaxNofDEs]),
fBPIds(new UInt_t[fMaxNofBPs]),
fBPProbas(new Float_t[fMaxNofBPs]),
fManuIds(new UInt_t[fMaxNofManus]),
fManuProbas(new Float_t[fMaxNofManus]),
fChannels(new AliMUON2DMap(kTRUE))
{
  /// normal ctor
  memset(fDEIds,0,fMaxNofDEs*sizeof(UInt_t));
  memset(fDEProbas,0,fMaxNofDEs*sizeof(Float_t));
  memset(fBPIds,0,fMaxNofBPs*sizeof(UInt_t));
  memset(fBPProbas,0,fMaxNofBPs*sizeof(Float_t));
  memset(fManuIds,0,fMaxNofManus*sizeof(UInt_t));
  memset(fManuProbas,0,fMaxNofManus*sizeof(Float_t));
}

//_____________________________________________________________________________
AliMUONRejectList::AliMUONRejectList(TRootIOCtor* /*ioCtor*/)
: TObject(),
fIsBinary(kTRUE),
fMaxNofDEs(),
fMaxNofBPs(),
fMaxNofManus(),
fNofDEs(), 
fNofBPs(), 
fNofManus(0), 
fDEIds(0x0),
fDEProbas(0x0),
fBPIds(0x0),
fBPProbas(0x0),
fManuIds(0x0),
fManuProbas(0x0),
fChannels(0x0)
{
  /// ctor from root i/o
}

//_____________________________________________________________________________
AliMUONRejectList::AliMUONRejectList(const AliMUONRejectList& rl)
: TObject(rl),
fIsBinary(rl.fIsBinary),
fMaxNofDEs(rl.fMaxNofDEs),
fMaxNofBPs(rl.fMaxNofBPs),
fMaxNofManus(rl.fMaxNofManus),
fNofDEs(rl.fNofDEs), 
fNofBPs(rl.fNofBPs), 
fNofManus(rl.fNofManus), 
fDEIds(0x0),
fDEProbas(0x0),
fBPIds(0x0),
fBPProbas(0x0),
fManuIds(0x0),
fManuProbas(0x0),
fChannels(0x0)
{
  /// Copy ctor
  
  ::Copy(rl.fMaxNofDEs,rl.fDEIds,fDEIds);
  ::Copy(rl.fMaxNofDEs,rl.fDEProbas,fDEProbas);
  ::Copy(rl.fMaxNofBPs,rl.fBPIds,fBPIds);
  ::Copy(rl.fMaxNofBPs,rl.fBPProbas,fBPProbas);
  ::Copy(rl.fMaxNofManus,rl.fManuIds,fManuIds);
  ::Copy(rl.fMaxNofManus,rl.fManuProbas,fManuProbas);
  
  if ( rl.fChannels ) 
  {
    fChannels = static_cast<AliMUONVStore*>(rl.fChannels->Clone());
  }
}

//_____________________________________________________________________________
AliMUONRejectList& AliMUONRejectList::operator=(const AliMUONRejectList& rl)
{
  /// assignement operator
  if ( this != &rl ) 
  {
    static_cast<TObject&>(*this)=rl;
    
    fIsBinary = rl.fIsBinary;
    fMaxNofDEs = rl.fMaxNofDEs;
    fMaxNofBPs = rl.fMaxNofBPs;
    fMaxNofManus = rl.fMaxNofManus;
    fNofDEs = rl.fNofDEs;
    fNofBPs = rl.fNofBPs;
    fNofManus = rl.fNofManus;
    
    ::Copy(rl.fMaxNofDEs,rl.fDEIds,fDEIds);
    ::Copy(rl.fMaxNofDEs,rl.fDEProbas,fDEProbas);
    ::Copy(rl.fMaxNofBPs,rl.fBPIds,fBPIds);
    ::Copy(rl.fMaxNofBPs,rl.fBPProbas,fBPProbas);
    ::Copy(rl.fMaxNofManus,rl.fManuIds,fManuIds);
    ::Copy(rl.fMaxNofManus,rl.fManuProbas,fManuProbas);
    
    delete fChannels;
    fChannels = 0x0;
    
    if ( rl.fChannels ) 
    {
      fChannels = static_cast<AliMUONVStore*>(rl.fChannels->Clone());
    }
    
  }  
  return *this;
}

//_____________________________________________________________________________
AliMUONRejectList::~AliMUONRejectList()
{
  /// dtor
  delete fChannels;
  delete[] fDEIds;
  delete[] fDEProbas;
  delete[] fBPIds;
  delete[] fBPProbas;
  delete[] fManuIds;
  delete[] fManuProbas;
}

//_____________________________________________________________________________
Float_t AliMUONRejectList::DetectionElementProbability(Int_t detElemId) const
{
  /// Get the probability to reject a given detection element
  return ::GetValue(fNofDEs,fDEIds,fDEProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,0));
}

//_____________________________________________________________________________
Float_t AliMUONRejectList::BusPatchProbability(Int_t busPatchId) const
{
  /// Get the probability to reject a given bus patch
  return ::GetValue(fNofBPs,fBPIds,fBPProbas,AliMUONVCalibParam::BuildUniqueID(busPatchId,0));
}

//_____________________________________________________________________________
Float_t AliMUONRejectList::ManuProbability(Int_t detElemId, Int_t manuId) const
{
  /// Get the probability to reject a given manu
  return ::GetValue(fNofManus,fManuIds,fManuProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,manuId));
}

//_____________________________________________________________________________
Float_t AliMUONRejectList::ChannelProbability(Int_t detElemId, Int_t manuId, Int_t manuChannel) const
{
  /// Get the probability to reject a given channel
  AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fChannels->FindObject(detElemId,manuId));
  if (!param) return 0.0;
  return param->ValueAsFloat(manuChannel);
}

//_____________________________________________________________________________
void AliMUONRejectList::SetDetectionElementProbability(Int_t detElemId, Float_t proba)
{
  /// Set the probability to reject a given detection element
  if ( ::SetValue(fNofDEs,fDEIds,fDEProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,0),proba) ) 
  {
    ++fNofDEs;
  }
  
  ZeroOrOne(proba);
}

//_____________________________________________________________________________
void AliMUONRejectList::ZeroOrOne(Float_t proba)
{
  /// If proba is anything else than 0 or 1, we set fIsBinary to kFALSe
  
  Bool_t zeroorone = ( proba == 0.0 || proba == 1.0 );
  if (!zeroorone) fIsBinary = kFALSE;
}

//_____________________________________________________________________________
void AliMUONRejectList::SetBusPatchProbability(Int_t busPatchId, Float_t proba)
{
  /// Set the probability to reject a given bus patch
  if ( ::SetValue(fNofBPs,fBPIds,fBPProbas,AliMUONVCalibParam::BuildUniqueID(busPatchId,0),proba) )
  {
    ++fNofBPs;
  }
  ZeroOrOne(proba);
}

//_____________________________________________________________________________
void AliMUONRejectList::SetManuProbability(Int_t detElemId, Int_t manuId, Float_t proba)
{
  /// Set the probability to reject a given manu
  if ( ::SetValue(fNofManus,fManuIds,fManuProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,manuId),proba) )
  {
    ++fNofManus;
  }
  ZeroOrOne(proba);
}

//_____________________________________________________________________________
void AliMUONRejectList::SetChannelProbability(Int_t detElemId, Int_t manuId, Int_t manuChannel, Float_t proba)
{
  /// Set the probability to reject a given channel
  AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fChannels->FindObject(detElemId,manuId));
  if (!param) 
  {
    param = new AliMUONCalibParamNF(1,AliMpConstants::ManuNofChannels(),detElemId,manuId,0.0);    
    fChannels->Add(param);
  }
  param->SetValueAsFloat(manuChannel,0,proba);
  ZeroOrOne(proba);
}

//_____________________________________________________________________________
void 
AliMUONRejectList::Print(Option_t* opt) const
{
  /// Printout

  TString sopt(opt);  
  sopt.ToUpper();
  Bool_t debug(kFALSE);
  
  if ( sopt.Contains("DEBUG") ) debug=kTRUE;
  
  cout << Form("We have probabilities for %d detection element(s), %d bus patch(es), %d manu(s)",
               fNofDEs,fNofBPs,fNofManus) << endl;
  
  ::Dump("DE %04d",fNofDEs,fDEIds,fDEProbas,debug);
  ::Dump("BusPatch %04d",fNofBPs,fBPIds,fBPProbas,debug);
  ::Dump("DE %04d MANU %4d",fNofManus,fManuIds,fManuProbas,debug);
}
Commit	Line	Data
fe783497	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
	18	///
	19	/// \class AliMUONRejectList
	20	///
	21	/// Object to hold the probability to reject elements during reconstruction.
	22	///
	23	/// Those elements are either channels, manus,
	24	/// bus patches, detection elements, or all the four.
	25	/// (we do not consider the next level, chamber, because if a full
	26	/// chamber is missing, we assume we'll remove that run from the
	27	/// list of usable runs anyway).
	28	///
	29	/// The probability of rejection can be different from 0.0 or 1.0 only for
	30	/// simulations, in which case it means that :
	31	/// - this object was created from inspection of real data occupancy maps + ad-hoc rejections over
	32	/// several runs
	33	/// - the probability then reflects the chance a given element was useable
	34	/// during data taking. For instance, if one DE has a probability of 0.8, it means
	35	/// it was on (or correctly behaving during data taking) only for 20% of the
	36	/// events.
	37	///
	38	/// \author Laurent Aphecetche, Subatech
	39	///
	40
	41	#include "AliMUONRejectList.h"
	42
	43	#include "AliMpConstants.h"
	44	#include "AliMUON2DMap.h"
	45	#include "AliMUONCalibParamNF.h"
	46	#include "Riostream.h"
	47	#include "TMath.h"
	48
b80faac0	49	using std::cout;
b80faac0	50	using std::endl;
fe783497	51	/// \cond CLASSIMP
	52	ClassImp(AliMUONRejectList)
	53	/// \endcond
	54
	55	namespace
	56	{
	57	/// The functions below are here to help re-invent the wheel,
	58	/// i.e. code something which acts as std::map<int,float>
	59	/// to circumvent the fact that AliRoot does not allow STL to be used.
	60
	61	void Dump(const char* str, UInt_t n, UInt_t* ids, Float_t* values, Bool_t debug)
	62	{
	63	/// Dump the values array
	64
	65	TString s(str);
	66	s += " PROBA %e";
	67
	68	for ( UInt_t i = 0; i < n; ++i )
	69	{
	70	UInt_t key = ids[i];
	71	Int_t a,b;
	72	AliMUONVCalibParam::DecodeUniqueID(key,a,b);
	73	if ( s.CountChar('%')==3 )
	74	{
	75	cout << Form(s.Data(),a,b,values[i]) << endl;
	76	}
	77	else
	78	{
	79	cout << Form(s.Data(),a,values[i]) << endl;
	80	}
	81	}
	82
	83	if ( debug )
	84	{
	85	cout << "------" << endl;
	86	for ( UInt_t i = 0; i < n; ++i )
	87	{
	88	UInt_t key = ids[i];
	89	Int_t a,b;
	90	AliMUONVCalibParam::DecodeUniqueID(key,a,b);
	91	cout << Form("ids[%5d]=%d values[%5d]=%e (a,b)=(%5d,%5d)",
	92	i,ids[i],i,values[i],a,b) << endl;
	93	}
	94
	95	}
	96	}
	97
	98	Float_t GetValue(UInt_t n, UInt_t* ids, Float_t* values, UInt_t key)
	99	{
	100	/// Get the value corresponding to key, or zero if not found
	101	Long64_t index = TMath::BinarySearch(n,ids,key);
	102
	103	Bool_t found = ( ( index >= 0 ) && ( ids[index] == key ) );
	104
	105	if ( found )
	106	{
	107	return values[index];
	108	}
	109	else
	110	{
	111	return 0.0;
	112	}
	113	}
	114
115	void Insert(UInt_t n, UInt_t* ids, Float_t* values, UInt_t index, UInt_t key, Float_t value)
116	{
117	/// Insert (key,value) into arrays ids and values.
118
119	for ( UInt_t i = n; i > index; --i )
120	{
121	ids[i] = ids[i-1];
122	values[i] = values[i-1];
123	}
124	ids[index] = key;
125	values[index] = value;
126	}
127
128	Bool_t SetValue(UInt_t n, UInt_t* ids, Float_t* values, UInt_t key, Float_t value)
129	{
130	/// Set the value for a given key
131	Long64_t index = TMath::BinarySearch(n,ids, key);
132
133	Bool_t alreadyThere = ( ( index >= 0 ) && ( ids[index] == key ) );
134
135	if ( alreadyThere )
136	{
137	// replacement
138	values[index] = value;
139	return kFALSE;
140	}
141	Insert(n,ids,values,index+1,key,value);
142	return kTRUE;
143	}
144
145	void Copy(UInt_t n, UInt_t* src, UInt_t*& dest)
146	{
147	/// Copy src into dest
148	delete[] dest;
62b6f26d	149	dest = 0;
	150	if ( src && n )
	151	{
	152	dest = new UInt_t[n];
c6496ae2	153	memcpy(dest,src,n*sizeof(UInt_t));
62b6f26d	154	}
fe783497	155	}
	156
	157	void Copy(UInt_t n, Float_t* src, Float_t*& dest)
	158	{
	159	/// Copy src into dest
	160	delete[] dest;
62b6f26d	161	dest = 0;
	162	if ( src && n )
	163	{
	164	dest = new Float_t[n];
c6496ae2	165	memcpy(dest,src,n*sizeof(Float_t));
62b6f26d	166	}
fe783497	167	}
	168
	169	}
	170
	171	//_____________________________________________________________________________
	172	AliMUONRejectList::AliMUONRejectList()
	173	: TObject(),
	174	fIsBinary(kTRUE),
	175	fMaxNofDEs(156), // not nice to put a constant here, but that way this object does not need the mapping at creation time...
	176	fMaxNofBPs(888), // same remark as above
	177	fMaxNofManus(16828), // same as above...
	178	fNofDEs(),
	179	fNofBPs(),
	180	fNofManus(),
	181	fDEIds(new UInt_t[fMaxNofDEs]),
	182	fDEProbas(new Float_t[fMaxNofDEs]),
	183	fBPIds(new UInt_t[fMaxNofBPs]),
	184	fBPProbas(new Float_t[fMaxNofBPs]),
	185	fManuIds(new UInt_t[fMaxNofManus]),
	186	fManuProbas(new Float_t[fMaxNofManus]),
	187	fChannels(new AliMUON2DMap(kTRUE))
	188	{
	189	/// normal ctor
	190	memset(fDEIds,0,fMaxNofDEs*sizeof(UInt_t));
74343395	191	memset(fDEProbas,0,fMaxNofDEs*sizeof(Float_t));
fe783497	192	memset(fBPIds,0,fMaxNofBPs*sizeof(UInt_t));
74343395	193	memset(fBPProbas,0,fMaxNofBPs*sizeof(Float_t));
fe783497	194	memset(fManuIds,0,fMaxNofManus*sizeof(UInt_t));
74343395	195	memset(fManuProbas,0,fMaxNofManus*sizeof(Float_t));
fe783497	196	}
	197
	198	//_____________________________________________________________________________
	199	AliMUONRejectList::AliMUONRejectList(TRootIOCtor* /ioCtor/)
	200	: TObject(),
	201	fIsBinary(kTRUE),
	202	fMaxNofDEs(),
	203	fMaxNofBPs(),
	204	fMaxNofManus(),
	205	fNofDEs(),
	206	fNofBPs(),
	207	fNofManus(0),
	208	fDEIds(0x0),
	209	fDEProbas(0x0),
	210	fBPIds(0x0),
	211	fBPProbas(0x0),
	212	fManuIds(0x0),
	213	fManuProbas(0x0),
	214	fChannels(0x0)
	215	{
	216	/// ctor from root i/o
	217	}
	218
	219	//_____________________________________________________________________________
	220	AliMUONRejectList::AliMUONRejectList(const AliMUONRejectList& rl)
	221	: TObject(rl),
c6496ae2	222	fIsBinary(rl.fIsBinary),
	223	fMaxNofDEs(rl.fMaxNofDEs),
	224	fMaxNofBPs(rl.fMaxNofBPs),
	225	fMaxNofManus(rl.fMaxNofManus),
	226	fNofDEs(rl.fNofDEs),
	227	fNofBPs(rl.fNofBPs),
	228	fNofManus(rl.fNofManus),
fe783497	229	fDEIds(0x0),
	230	fDEProbas(0x0),
	231	fBPIds(0x0),
	232	fBPProbas(0x0),
	233	fManuIds(0x0),
	234	fManuProbas(0x0),
	235	fChannels(0x0)
	236	{
	237	/// Copy ctor
c6496ae2	238
	239	::Copy(rl.fMaxNofDEs,rl.fDEIds,fDEIds);
	240	::Copy(rl.fMaxNofDEs,rl.fDEProbas,fDEProbas);
	241	::Copy(rl.fMaxNofBPs,rl.fBPIds,fBPIds);
	242	::Copy(rl.fMaxNofBPs,rl.fBPProbas,fBPProbas);
	243	::Copy(rl.fMaxNofManus,rl.fManuIds,fManuIds);
	244	::Copy(rl.fMaxNofManus,rl.fManuProbas,fManuProbas);
	245
	246	if ( rl.fChannels )
	247	{
	248	fChannels = static_cast<AliMUONVStore*>(rl.fChannels->Clone());
	249	}
fe783497	250	}
	251
	252	//_____________________________________________________________________________
	253	AliMUONRejectList& AliMUONRejectList::operator=(const AliMUONRejectList& rl)
	254	{
	255	/// assignement operator
6350d0c0	256	if ( this != &rl )
6350d0c0	257	{
c6496ae2	258	static_cast<TObject&>(*this)=rl;
	259
	260	fIsBinary = rl.fIsBinary;
	261	fMaxNofDEs = rl.fMaxNofDEs;
	262	fMaxNofBPs = rl.fMaxNofBPs;
	263	fMaxNofManus = rl.fMaxNofManus;
	264	fNofDEs = rl.fNofDEs;
	265	fNofBPs = rl.fNofBPs;
	266	fNofManus = rl.fNofManus;
	267
	268	::Copy(rl.fMaxNofDEs,rl.fDEIds,fDEIds);
	269	::Copy(rl.fMaxNofDEs,rl.fDEProbas,fDEProbas);
	270	::Copy(rl.fMaxNofBPs,rl.fBPIds,fBPIds);
	271	::Copy(rl.fMaxNofBPs,rl.fBPProbas,fBPProbas);
	272	::Copy(rl.fMaxNofManus,rl.fManuIds,fManuIds);
	273	::Copy(rl.fMaxNofManus,rl.fManuProbas,fManuProbas);
	274
	275	delete fChannels;
	276	fChannels = 0x0;
	277
	278	if ( rl.fChannels )
	279	{
	280	fChannels = static_cast<AliMUONVStore*>(rl.fChannels->Clone());
	281	}
	282
6350d0c0	283	}
fe783497	284	return *this;
	285	}
	286
fe783497	287	//_____________________________________________________________________________
	288	AliMUONRejectList::~AliMUONRejectList()
	289	{
	290	/// dtor
	291	delete fChannels;
	292	delete[] fDEIds;
	293	delete[] fDEProbas;
	294	delete[] fBPIds;
	295	delete[] fBPProbas;
	296	delete[] fManuIds;
	297	delete[] fManuProbas;
	298	}
	299
	300	//_____________________________________________________________________________
	301	Float_t AliMUONRejectList::DetectionElementProbability(Int_t detElemId) const
	302	{
	303	/// Get the probability to reject a given detection element
	304	return ::GetValue(fNofDEs,fDEIds,fDEProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,0));
	305	}
	306
	307	//_____________________________________________________________________________
	308	Float_t AliMUONRejectList::BusPatchProbability(Int_t busPatchId) const
	309	{
	310	/// Get the probability to reject a given bus patch
	311	return ::GetValue(fNofBPs,fBPIds,fBPProbas,AliMUONVCalibParam::BuildUniqueID(busPatchId,0));
	312	}
	313
	314	//_____________________________________________________________________________
	315	Float_t AliMUONRejectList::ManuProbability(Int_t detElemId, Int_t manuId) const
	316	{
	317	/// Get the probability to reject a given manu
	318	return ::GetValue(fNofManus,fManuIds,fManuProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,manuId));
	319	}
	320
	321	//_____________________________________________________________________________
	322	Float_t AliMUONRejectList::ChannelProbability(Int_t detElemId, Int_t manuId, Int_t manuChannel) const
	323	{
	324	/// Get the probability to reject a given channel
	325	AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fChannels->FindObject(detElemId,manuId));
	326	if (!param) return 0.0;
	327	return param->ValueAsFloat(manuChannel);
	328	}
	329
	330	//_____________________________________________________________________________
	331	void AliMUONRejectList::SetDetectionElementProbability(Int_t detElemId, Float_t proba)
	332	{
	333	/// Set the probability to reject a given detection element
	334	if ( ::SetValue(fNofDEs,fDEIds,fDEProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,0),proba) )
	335	{
	336	++fNofDEs;
	337	}
	338
	339	ZeroOrOne(proba);
	340	}
	341
	342	//_____________________________________________________________________________
	343	void AliMUONRejectList::ZeroOrOne(Float_t proba)
	344	{
	345	/// If proba is anything else than 0 or 1, we set fIsBinary to kFALSe
	346
	347	Bool_t zeroorone = ( proba == 0.0 \|\| proba == 1.0 );
	348	if (!zeroorone) fIsBinary = kFALSE;
	349	}
	350
351	//_____________________________________________________________________________
352	void AliMUONRejectList::SetBusPatchProbability(Int_t busPatchId, Float_t proba)
353	{
354	/// Set the probability to reject a given bus patch
355	if ( ::SetValue(fNofBPs,fBPIds,fBPProbas,AliMUONVCalibParam::BuildUniqueID(busPatchId,0),proba) )
356	{
357	++fNofBPs;
358	}
359	ZeroOrOne(proba);
360	}
361
362	//_____________________________________________________________________________
363	void AliMUONRejectList::SetManuProbability(Int_t detElemId, Int_t manuId, Float_t proba)
364	{
365	/// Set the probability to reject a given manu
366	if ( ::SetValue(fNofManus,fManuIds,fManuProbas,AliMUONVCalibParam::BuildUniqueID(detElemId,manuId),proba) )
367	{
368	++fNofManus;
369	}
370	ZeroOrOne(proba);
371	}
372
373	//_____________________________________________________________________________
374	void AliMUONRejectList::SetChannelProbability(Int_t detElemId, Int_t manuId, Int_t manuChannel, Float_t proba)
375	{
376	/// Set the probability to reject a given channel
377	AliMUONVCalibParam* param = static_cast<AliMUONVCalibParam*>(fChannels->FindObject(detElemId,manuId));
378	if (!param)
379	{
380	param = new AliMUONCalibParamNF(1,AliMpConstants::ManuNofChannels(),detElemId,manuId,0.0);
381	fChannels->Add(param);
382	}
383	param->SetValueAsFloat(manuChannel,0,proba);
384	ZeroOrOne(proba);
385	}
386
387	//_____________________________________________________________________________
388	void
389	AliMUONRejectList::Print(Option_t* opt) const
390	{
391	/// Printout
392
393	TString sopt(opt);
394	sopt.ToUpper();
395	Bool_t debug(kFALSE);
396
397	if ( sopt.Contains("DEBUG") ) debug=kTRUE;
398
399	cout << Form("We have probabilities for %d detection element(s), %d bus patch(es), %d manu(s)",
400	fNofDEs,fNofBPs,fNofManus) << endl;
401
402	::Dump("DE %04d",fNofDEs,fDEIds,fDEProbas,debug);
403	::Dump("BusPatch %04d",fNofBPs,fBPIds,fBPProbas,debug);
404	::Dump("DE %04d MANU %4d",fNofManus,fManuIds,fManuProbas,debug);
405	}