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

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