#include "AliMUONDigitizerv2.h"
#include "AliMUONSDigitizerv1.h"
#include "AliMUONRawData.h"
+#include "AliLog.h"
// Defaults parameters for Z positions of chambers
// taken from values for "stations" in AliMUON::AliMUON
{
// Protected copy constructor
- Fatal("AliMUONMergerModule", "Not implemented.");
+ AliFatal("Not implemented.");
}
//____________________________________________________________________
AliMUON::~AliMUON()
{
// Destructor
- if(fDebug) printf("%s: Calling AliMUON destructor !!!\n",ClassName());
+ AliDebug(1,"Calling AliMUON destructor");
fIshunt = 0;
if (fMerger) delete fMerger;
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
// write TreeD here
if (!fMerger) {
- if (gAlice->GetDebug()>0) {
- cerr<<"AliMUON::SDigits2Digits: create default AliMUONMerger "<<endl;
- cerr<<" no merging, just digitization of 1 event will be done"<<endl;
- }
- fMerger = new AliMUONMerger();
+ AliDebug(1,"Create default AliMUONMerger ");
+ AliDebug(1," no merging, just digitization of 1 event will be done");
+ fMerger = new AliMUONMerger();
}
fMerger->Init();
fMerger->Digitise();
AliMUONRawData* rawData;
rawData = new AliMUONRawData(fLoader);
- if (!rawData->WriteRawData()) Info("MUON","pb writting raw data");
+ if (!rawData->WriteRawData()) AliInfo("pb writting raw data");
delete rawData;
return;
}
//builds standard getter (AliLoader type)
//if detector wants to use castomized getter, it must overload this method
- if (GetDebug())
- Info("MakeLoader",
- "Creating standard getter for detector %s. Top folder is %s.",
- GetName(),topfoldername);
+
+ AliDebug(1,Form("Creating standard getter for detector %s. Top folder is %s.",
+ GetName(),topfoldername));
fLoader = new AliLoader(GetName(),topfoldername);
fMUONData = new AliMUONData(fLoader,GetName(),GetName());
fMUONData->SetSplitLevel(fSplitLevel);
// --- MUON includes ---
#include "AliMUONChamber.h"
#include "AliMUONChamberGeometry.h"
+#include "AliLog.h"
ClassImp(AliMUONChamber)
{
// Protected copy constructor
- Fatal("AliMUONMergerModule", "Not implemented.");
+ AliFatal("Not implemented.");
// Dummy copy constructor
}
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
if (nnew >= 500) // Perform a bounds check on nnew since it is assumed
// newclust only contains 500 elements.
{
- Error("DisIntegration", "Limit of 500 pad responses reached.");
+ AliError("Limit of 500 pad responses reached.");
return;
};
//
#include "AliMUONGeometryEnvelopeStore.h"
#include "AliMUONGeometryTransformStore.h"
#include "AliMUONConstants.h"
+#include "AliLog.h"
ClassImp(AliMUONChamberGeometry)
AliMUONChamberGeometry::AliMUONChamberGeometry(const AliMUONChamberGeometry& rhs)
: TObject(rhs)
{
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
segmentation->GetPadI(xhit,yhit,0,ix,iy);
segmentation->SetPad(ix,iy);
-
+
// treatment of GEANT hits w/o corresponding strip (due to the fact that
// the 2 geometries are computed in a very slightly different way)
if (ix==0&&iy==0) {
#include "AliMUONClusterInput.h"
#include "AliMUONPixel.h"
#include "AliMC.h"
+#include "AliLog.h"
ClassImp(AliMUONClusterFinderAZ)
{
// Protected copy constructor
- Fatal("AliMUONClusterFinderAZModule", "Not implemented.");
+ AliFatal("Not implemented.");
}
//_____________________________________________________________________________
muon->ResetRawClusters();
nent = (Int_t) treeR->GetEntries();
if (nent != 1) {
- cout << "Error in MUONdrawClust" << endl;
- cout << " nent = " << nent << " not equal to 1" << endl;
+ AliError(Form("nent = %d not equal to 1",nent));
//exit(0);
}
} // if (treeR)
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
#include "AliMUONResponse.h"
#include "AliMUONClusterInput.h"
#include "AliMUONHitMapA1.h"
+#include "AliLog.h"
//_____________________________________________________________________
// This function is minimized in the double-Mathieson fit
{
// Protected copy constructor
- Fatal("AliMUONClusterFinderAZModule", "Not implemented.");
+ AliFatal("Not implemented.");
}
//____________________________________________________________________________
void AliMUONClusterFinderVS::ResetRawClusters()
fXInit[0]=c->GetX(1);
fYInit[0]=c->GetY(1);
}
- if (fDebugLevel)
- fprintf(stderr,"\n cas (1) CombiSingleMathiesonFit(c)\n");
+ AliDebug(1,"cas (1) CombiSingleMathiesonFit(c)");
chi2=CombiSingleMathiesonFit(c);
// Int_t ndf = fgNbins[0]+fgNbins[1]-2;
// Float_t prob = TMath::Prob(Double_t(chi2),ndf);
// prob1->Fill(prob);
// chi2_1->Fill(chi2);
oldchi2=chi2;
- if (fDebugLevel)
- fprintf(stderr," chi2 %f ",chi2);
+ AliDebug(1,Form(" chi2 %f ",chi2));
c->SetX(0, fXFit[0]);
c->SetY(0, fYFit[0]);
// chi2_2->Fill(chi2);
// Was this any better ??
- if (fDebugLevel)
- fprintf(stderr," Old and new chi2 %f %f ", oldchi2, chi2);
+ AliDebug(1,Form(" Old and new chi2 %f %f ", oldchi2, chi2));
if (fFitStat!=0 && chi2>0 && (2.*chi2 < oldchi2)) {
- if (fDebugLevel)
- fprintf(stderr," Split\n");
+ AliDebug(1,"Split");
// Split cluster into two according to fit result
Split(c);
} else {
- if (fDebugLevel)
- fprintf(stderr," Don't Split\n");
+ AliDebug(1,"Do not Split");
// Don't split
AddRawCluster(*c);
}
// 1 maximum is initialised with the maximum of the combination found (X->cathode 2, Y->cathode 1)
// 1 maximum is initialised with the other maximum of the first cathode
if (accepted[0]){
- if (fDebugLevel) fprintf(stderr,"ico=0\n");
+ AliDebug(1,"ico=0");
fXInit[0]=xm[0][1];
fYInit[0]=ym[0][0];
fXInit[1]=xm[3][0];
fYInit[1]=ym[3][0];
} else if (accepted[1]){
- if (fDebugLevel) fprintf(stderr,"ico=1\n");
+ AliDebug(1,"ico=1");
fXInit[0]=xm[1][1];
fYInit[0]=ym[1][0];
fXInit[1]=xm[2][0];
fYInit[1]=ym[2][0];
} else if (accepted[2]){
- if (fDebugLevel) fprintf(stderr,"ico=2\n");
+ AliDebug(1,"ico=2");
fXInit[0]=xm[2][1];
fYInit[0]=ym[2][0];
fXInit[1]=xm[1][0];
fYInit[1]=ym[1][0];
} else if (accepted[3]){
- if (fDebugLevel) fprintf(stderr,"ico=3\n");
+ AliDebug(1,"ico=3");
fXInit[0]=xm[3][1];
fYInit[0]=ym[3][0];
fXInit[1]=xm[0][0];
fYInit[1]=ym[0][0];
}
- if (fDebugLevel)
- fprintf(stderr,"\n cas (2) CombiDoubleMathiesonFit(c)\n");
+ AliDebug(1,"cas (2) CombiDoubleMathiesonFit(c)");
chi2=CombiDoubleMathiesonFit(c);
// Int_t ndf = fgNbins[0]+fgNbins[1]-6;
// Float_t prob = TMath::Prob(chi2,ndf);
// prob2->Fill(prob);
// chi2_2->Fill(chi2);
- if (fDebugLevel)
- fprintf(stderr," chi2 %f\n",chi2);
+ AliDebug(1,Form(" chi2 %f\n",chi2));
// If reasonable chi^2 add result to the list of rawclusters
if (chi2<10) {
// 1 maximum is initialised with the maximum of the combination found (X->cathode 2, Y->cathode 1)
// 1 maximum is initialised with the other maximum of the second cathode
if (accepted[0]){
- if (fDebugLevel) fprintf(stderr,"ico=0\n");
+ AliDebug(1,"ico=0");
fXInit[0]=xm[0][1];
fYInit[0]=ym[0][0];
fXInit[1]=xm[3][1];
fYInit[1]=ym[3][1];
} else if (accepted[1]){
- if (fDebugLevel) fprintf(stderr,"ico=1\n");
+ AliDebug(1,"ico=1");
fXInit[0]=xm[1][1];
fYInit[0]=ym[1][0];
fXInit[1]=xm[2][1];
fYInit[1]=ym[2][1];
} else if (accepted[2]){
- if (fDebugLevel) fprintf(stderr,"ico=2\n");
+ AliDebug(1,"ico=2");
fXInit[0]=xm[2][1];
fYInit[0]=ym[2][0];
fXInit[1]=xm[1][1];
fYInit[1]=ym[1][1];
} else if (accepted[3]){
- if (fDebugLevel) fprintf(stderr,"ico=3\n");
+ AliDebug(1,"ico=3");
fXInit[0]=xm[3][1];
fYInit[0]=ym[3][0];
fXInit[1]=xm[0][1];
fYInit[1]=ym[0][1];
}
- if (fDebugLevel)
- fprintf(stderr,"\n cas (2) CombiDoubleMathiesonFit(c)\n");
+ AliDebug(1,"\n cas (2) CombiDoubleMathiesonFit(c)\n");
chi2=CombiDoubleMathiesonFit(c);
// Int_t ndf = fgNbins[0]+fgNbins[1]-6;
// Float_t prob = TMath::Prob(chi2,ndf);
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
#include "AliMUONResponse.h"
#include "AliMUONRawCluster.h"
#include "AliMUONDigit.h"
+#include "AliLog.h"
ClassImp(AliMUONClusterInput)
{
// Protected copy constructor
- Fatal("AliMUONClusterInput", "Not implemented.");
+ AliFatal("Not implemented.");
}
void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig1, TClonesArray* dig2)
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
#include "AliMUONClusterInput.h"
#include "AliMUONRawCluster.h"
#include "AliRawReader.h" // for raw data
+#include "AliLog.h"
const Int_t AliMUONClusterReconstructor::fgkDefaultPrintLevel = 0;
{
// Protected copy constructor
- Fatal("AliMUONClusterReconstructor", "Not implemented.");
+ AliFatal("Not implemented.");
}
//_______________________________________________________________________
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
//TClonesArray *
muonDigits = fMUONData->Digits(ich);
ndig=muonDigits->GetEntriesFast();
- if(fDebug)
- printf("1 Found %d digits in %p chamber %d\n", ndig, (void*)muonDigits,ich);
+ AliDebug(1,Form("1 Found %d digits in %p chamber %d", ndig, (void*)muonDigits,ich));
TClonesArray &lhits1 = *dig1;
Int_t n = 0;
for (k = 0; k < ndig; k++) {
fMUONData->GetCathode(1);
muonDigits = fMUONData->Digits(ich);
ndig=muonDigits->GetEntriesFast();
- if(fDebug)
- printf("\n 2 Found %d digits in %p %d", ndig, (void*)muonDigits, ich);
+ AliDebug(1,Form("2 Found %d digits in %p %d", ndig, (void*)muonDigits, ich));
TClonesArray &lhits2 = *dig2;
n=0;
// Perform cluster finding form raw data
- Fatal("Digits2Clusters","clusterization not implemented for raw data input");
+ AliFatal("clusterization not implemented for raw data input");
}
#include "AliMUONConstants.h"
-
ClassImp(AliMUONConstants)
Int_t AliMUONConstants::fgNCh = 14;
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-
+
#include "AliMUONDDLTracker.h"
#include "AliRawDataHeader.h"
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-
+
#include "AliMUONDDLTrigger.h"
ClassImp(AliMUONDDLTrigger)
#include "AliMUONRawCluster.h"
#include "AliMUONTrack.h"
#include "AliMUONTriggerTrack.h"
+#include "AliLog.h"
ClassImp(AliMUONData)
{
// Protected copy constructor
- Fatal("AliMUONData", "Not implemented.");
+ AliFatal("Not implemented.");
}
//_____________________________________________________________________________
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
{
// Checking if there are RawCluster Branches In TreeR
if (TreeR()==0x0) {
- Error("TreeR","No treeR in memory");
+ AliError("No treeR in memory");
return kFALSE;
}
else {
{
// Checking if there are RawCluster Branches In TreeR
if (TreeD()==0x0) {
- Error("TreeD","No treeD in memory");
+ AliError("No treeD in memory");
return kFALSE;
}
else {
{
// Checking if there are Trigger Branches In TreeR
if (TreeR()==0x0) {
- Error("TreeR","No treeR in memory");
+ AliError("No treeR in memory");
return kFALSE;
}
else {
{
// Checking if there are Trigger Branches In TreeR
if (TreeD()==0x0) {
- Error("TreeD","No treeD in memory");
+ AliError("No treeD in memory");
return kFALSE;
}
else {
{
// Checking if there are Track Branches In TreeT
if (TreeT()==0x0) {
- Error("TreeT","No treeT in memory");
+ AliError("No treeT in memory");
return kFALSE;
}
else {
{
// Checking if there are TriggerTrack Branches In TreeT
if (TreeT()==0x0) {
- Error("TreeT","No treeT in memory");
+ AliError("No treeT in memory");
return kFALSE;
}
else {
sprintf(branchname,"%sHits",GetName());
branch = TreeH()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch %s is already in tree.",GetName());
+ AliInfo(Form("MakeBranch","Branch %s is already in tree.",GetName()));
return ;
}
branch = TreeH()->Branch(branchname,&fHits,kBufferSize);
branch = 0x0;
branch = TreeD()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch %s is already in tree.",GetName());
+ AliInfo(Form("Branch %s is already in tree.",GetName()));
return;
}
TClonesArray * digits = Digits(iDetectionPlane);
}
branch = TreeD()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch GlobalTrigger is already in treeD.");
+ AliInfo(Form("Branch GlobalTrigger is already in treeD."));
return ;
}
branch = TreeD()->Branch(branchname, &fGlobalTrigger, kBufferSize);
}
branch = TreeD()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch LocalTrigger is already in treeD.");
+ AliInfo(Form("Branch LocalTrigger is already in treeD."));
return;
}
branch = TreeD()->Branch(branchname, &fLocalTrigger, kBufferSize);
branch = 0x0;
branch = TreeS()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch %s is already in tree.",GetName());
+ AliInfo(Form("Branch %s is already in tree.",GetName()));
return;
}
TClonesArray * sdigits = SDigits(iDetectionPlane);
branch = 0x0;
branch = TreeR()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch %s is already in tree.",GetName());
+ AliInfo(Form("Branch %s is already in tree.",GetName()));
return;
}
branch = TreeR()->Branch(branchname, &((*fRawClusters)[i]),kBufferSize);
}
branch = TreeR()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch GlobalTrigger is already in treeR.");
+ AliInfo(Form("Branch GlobalTrigger is already in treeR."));
return ;
}
branch = TreeR()->Branch(branchname, &fGlobalTrigger, kBufferSize);
}
branch = TreeR()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch LocalTrigger is already in treeR.");
+ AliInfo(Form("Branch LocalTrigger is already in treeR."));
return;
}
branch = TreeR()->Branch(branchname, &fLocalTrigger, kBufferSize);
sprintf(branchname,"%sTrack",GetName());
branch = TreeT()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch %s is already in tree.",GetName());
+ AliInfo(Form("Branch %s is already in tree.",GetName()));
return ;
}
branch = TreeT()->Branch(branchname,&fRecTracks,kBufferSize);
sprintf(branchname,"%sTriggerTrack",GetName());
branch = TreeT()->GetBranch(branchname);
if (branch) {
- Info("MakeBranch","Branch %s is already in tree.",GetName());
+ AliInfo(Form("Branch %s is already in tree.",GetName()));
return ;
}
branch = TreeT()->Branch(branchname,&fRecTriggerTracks,kBufferSize);
branch->SetAddress(&fHits);
}
else { //can be invoked before branch creation
- Warning("SetTreeAddress","(%s) Failed for Hits. Can not find branch in tree.",GetName());
+ AliWarning(Form("(%s) Failed for Hits. Can not find branch in tree.",GetName()));
}
}
if (branch) {
branch->SetAddress( &digits );
}
- else Warning("SetTreeAddress","(%s) Failed for Digits Detection plane %d. Can not find branch in tree.",GetName(),i);
+ else AliWarning(Form("(%s) Failed for Digits Detection plane %d. Can not find branch in tree.",GetName(),i));
}
}
}
sprintf(branchname,"%sLocalTrigger",GetName());
branch = TreeD()->GetBranch(branchname);
if (branch) branch->SetAddress(&fLocalTrigger);
- else Warning("SetTreeAddress","(%s) Failed for LocalTrigger. Can not find branch in treeD.",GetName());
+ else AliWarning(Form("(%s) Failed for LocalTrigger. Can not find branch in treeD.",GetName()));
}
if ( TreeD() && fGlobalTrigger && cGLT) {
sprintf(branchname,"%sGlobalTrigger",GetName());
branch = TreeD()->GetBranch(branchname);
if (branch) branch->SetAddress(&fGlobalTrigger);
- else Warning("SetTreeAddress","(%s) Failed for GlobalTrigger. Can not find branch in treeD.",GetName());
+ else AliWarning(Form("(%s) Failed for GlobalTrigger. Can not find branch in treeD.",GetName()));
}
//
branch = TreeS()->GetBranch(branchname);
TClonesArray * sdigits = SDigits(i);
if (branch) branch->SetAddress( &sdigits );
- else Warning("SetTreeAddress","(%s) Failed for SDigits Detection plane %d. Can not find branch in tree.",GetName(),i);
+ else AliWarning(Form("(%s) Failed for SDigits Detection plane %d. Can not find branch in tree.",GetName(),i));
}
}
}
if (fRawClusters) {
branch = TreeR()->GetBranch(branchname);
if (branch) branch->SetAddress( &((*fRawClusters)[i]) );
- else Warning("SetTreeAddress","(%s) Failed for RawClusters Detection plane %d. Can not find branch in tree.",GetName(),i);
+ else AliWarning(Form("(%s) Failed for RawClusters Detection plane %d. Can not find branch in tree.",GetName(),i));
}
}
}
sprintf(branchname,"%sLocalTrigger",GetName());
branch = TreeR()->GetBranch(branchname);
if (branch) branch->SetAddress(&fLocalTrigger);
- else Warning("SetTreeAddress","(%s) Failed for LocalTrigger. Can not find branch in treeR.",GetName());
+ else AliWarning(Form("(%s) Failed for LocalTrigger. Can not find branch in treeR.",GetName()));
}
if ( TreeR() && fGlobalTrigger && cTC) {
sprintf(branchname,"%sGlobalTrigger",GetName());
branch = TreeR()->GetBranch(branchname);
if (branch) branch->SetAddress(&fGlobalTrigger);
- else Warning("SetTreeAddress","(%s) Failed for GlobalTrigger. Can not find branch in treeR.",GetName());
+ else AliWarning(Form("(%s) Failed for GlobalTrigger. Can not find branch in treeR.",GetName()));
}
if ( TreeT() ) {
sprintf(branchname,"%sTrack",GetName());
branch = TreeT()->GetBranch(branchname);
if (branch) branch->SetAddress(&fRecTracks);
- else Warning("SetTreeAddress","(%s) Failed for Tracks. Can not find branch in tree.",GetName());
+ else AliWarning(Form("(%s) Failed for Tracks. Can not find branch in tree.",GetName()));
}
// trigger tracks
if ( TreeT() ) {
sprintf(branchname,"%sTriggerTrack",GetName());
branch = TreeT()->GetBranch(branchname);
if (branch) branch->SetAddress(&fRecTriggerTracks);
- else Warning("SetTreeAddress","(%s) Failed for Trigger Tracks. Can not find branch in tree.",GetName());
+ else AliWarning(Form("(%s) Failed for Trigger Tracks. Can not find branch in tree.",GetName()));
}
#include "AliMUONHit.h"
#include "AliMUONDigit.h"
#include "AliMUONRawCluster.h"
+#include "AliLog.h"
ClassImp(AliMUONDataInterface)
{
// Protected copy constructor
- Fatal("AliMUONDataInterface", "Not implemented.");
+ AliFatal("Not implemented.");
}
AliMUONDataInterface::~AliMUONDataInterface()
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
fRunloader = AliRunLoader::Open(filename, foldername, "READ");
if (fRunloader == NULL)
{
- Error("LoadLoaders", "Could not find or load the run loader for the file: %s and folder: %s",
- (const char*)filename, (const char*)foldername);
+ AliError(Form("Could not find or load the run loader for the file: %s and folder: %s",
+ (const char*)filename, (const char*)foldername));
return kFALSE;
};
fMuonloader = fRunloader->GetLoader("MUONLoader");
if (fMuonloader == NULL)
{
- Error("LoadLoaders", "Could not find the MUON loader in file: %s and folder: %s",
- (const char*)filename, (const char*)foldername);
+ AliError(Form("Could not find the MUON loader in file: %s and folder: %s",
+ (const char*)filename, (const char*)foldername));
fRunloader = NULL;
return kFALSE;
};
fRunloader->LoadKinematics("READ");
if (fRunloader->TreeK() == NULL)
{
- Error("FetchTreeK", "Could not load TreeK.");
+ AliError("Could not load TreeK.");
return kFALSE;
};
};
fMuonloader->LoadHits("READ");
if (fMuonloader->TreeH() == NULL)
{
- Error("FetchTreeH", "Could not load TreeH.");
+ AliError("Could not load TreeH.");
return kFALSE;
};
fData.SetTreeAddress("H");
fMuonloader->LoadSDigits("READ");
if (fMuonloader->TreeS() == NULL)
{
- Error("FetchTreeS", "Could not load TreeS.");
+ AliError("Could not load TreeS.");
return kFALSE;
};
fData.SetTreeAddress("S");
fMuonloader->LoadDigits("READ");
if (fMuonloader->TreeD() == NULL)
{
- Error("FetchTreeD", "Could not load TreeD.");
+ AliError("Could not load TreeD.");
return kFALSE;
};
fData.SetTreeAddress("D");
fMuonloader->LoadRecPoints("READ");
if (fMuonloader->TreeR() == NULL)
{
- Error("FetchTreeR", "Could not load TreeR.");
+ AliError("Could not load TreeR.");
return kFALSE;
};
if (fRunloader == NULL)
{
- Error("NumberOfEvents", "File not set.");
+ AliError("File not set.");
return -1;
};
return fRunloader->GetNumberOfEvents();
if (fRunloader == NULL)
{
- Error("NumberOfParticles", "File not set.");
+ AliError("File not set.");
return -1;
};
if ( ! FetchTreeK() ) return -1;
if (fRunloader == NULL)
{
- Error("Particle", "File not set.");
+ AliError("File not set.");
return NULL;
};
if (fEventnumber < 0)
{
- Error("Particle", "Event not chosen.");
+ AliError("Event not chosen.");
return NULL;
};
if ( ! FetchTreeK() ) return NULL;
if (fRunloader == NULL)
{
- Error("NumberOfTracks", "File not set.");
+ AliError("File not set.");
return -1;
};
if (fEventnumber < 0)
{
- Error("NumberOfTracks", "Event not chosen.");
+ AliError( "Event not chosen.");
return -1;
};
if ( ! FetchTreeH() ) return -1;
if (fRunloader == NULL)
{
- Error("NumberOfHits", "File not set.");
+ AliError("File not set.");
return -1;
};
if (fEventnumber < 0)
{
- Error("NumberOfHits", "Event not chosen.");
+ AliError("Event not chosen.");
return -1;
};
if ( ! FetchTreeH() ) return -1;
if (fRunloader == NULL)
{
- Error("Hit", "File not set.");
+ AliError("File not set.");
return NULL;
};
if (fEventnumber < 0)
{
- Error("Hit", "Event not chosen.");
+ AliError("Event not chosen.");
return NULL;
};
if ( ! FetchTreeH() ) return NULL;
if (fRunloader == NULL)
{
- Error("NumberOfSDigits", "File not set.");
+ AliError("File not set.");
return -1;
};
if (fEventnumber < 0)
{
- Error("NumberOfSDigits", "Event not chosen.");
+ AliError("Event not chosen.");
return -1;
};
if (fRunloader == NULL)
{
- Error("SDigit", "File not set.");
+ AliError("File not set.");
return NULL;
};
if (fEventnumber < 0)
{
- Error("SDigit", "Event not chosen.");
+ AliError("Event not chosen.");
return NULL;
};
if (fRunloader == NULL)
{
- Error("NumberOfDigits", "File not set.");
+ AliError("File not set.");
return -1;
};
if (fEventnumber < 0)
{
- Error("NumberOfDigits", "Event not chosen.");
+ AliError("Event not chosen.");
return -1;
};
if (fRunloader == NULL)
{
- Error("Digit", "File not set.");
+ AliError("File not set.");
return NULL;
};
if (fEventnumber < 0)
{
- Error("Digit", "Event not chosen.");
+ AliError("Event not chosen.");
return NULL;
};
if (fRunloader == NULL)
{
- Error("NumberOfRawClusters", "File not set.");
+ AliError("File not set.");
return -1;
};
if (fEventnumber < 0)
{
- Error("NumberOfRawClusters", "Event not chosen.");
+ AliError("Event not chosen.");
return -1;
};
if (fRunloader == NULL)
{
- Error("RawCluster", "File not set.");
+ AliError("File not set.");
return NULL;
};
if (fEventnumber < 0)
{
- Error("RawCluster", "Event not chosen.");
+ AliError("Event not chosen.");
return NULL;
};
if (fRunloader == NULL)
{
- Error("NumberOfLocalTriggers", "File not set.");
+ AliError("File not set.");
return -1;
};
if (fEventnumber < 0)
{
- Error("NumberOfLocalTriggers", "Event not chosen.");
+ AliError("Event not chosen.");
return -1;
};
if (fRunloader == NULL)
{
- Error("LocalTrigger", "File not set.");
+ AliError("File not set.");
return NULL;
};
if (fEventnumber < 0)
{
- Error("LocalTrigger", "Event not chosen.");
+ AliError( "Event not chosen.");
return NULL;
};
#include "AliMUONDigit.h"
+
ClassImp(AliMUONDigit)
//_____________________________________________________________________________
AliMUONDigit::AliMUONDigit(const AliMUONDigit& digits):TObject(digits)
#include "AliMUONTransientDigit.h"
#include "AliMUONHitMapA1.h"
#include "AliMUONTriggerDecision.h"
+#include "AliLog.h"
/////////////////////////////////////////////////////////////////////////////////////
{
// Protected copy constructor
- Fatal("AliMUONDigitizer", "Not implemented.");
+ AliFatal("Not implemented.");
}
//___________________________________________
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
// 2) Loop over the generated transient digits and write them to the output
// stream. Done in CreateDigits()
- if (GetDebug() > 0) Info("Exec", "Running digitiser.");
+ AliDebug(1, "Running digitiser.");
ParseOptions(option);
if (fManager->GetNinputs() == 0)
{
- Warning("Exec", "No inputs set, nothing to do.");
+ AliWarning("No inputs set, nothing to do.");
return;
};
InitArrays();
- if (GetDebug() > 1) Info("Exec", "Event Number is %d.", fManager->GetOutputEventNr());
+ AliDebug(2, Form("Event Number is %d.", fManager->GetOutputEventNr()));
// Loop over files to merge and to digitize
fSignal = kTRUE;
for (Int_t inputFile = 0; inputFile < fManager->GetNinputs(); inputFile++)
{
fMask = fManager->GetMask(inputFile);
- if (GetDebug() > 1)
- Info("Exec", "Digitising folder %d, with fMask = %d: %s", inputFile, fMask,
- (const char*)fManager->GetInputFolderName(inputFile));
+ AliDebug(2, Form("Digitising folder %d, with fMask = %d: %s", inputFile, fMask,
+ (const char*)fManager->GetInputFolderName(inputFile)));
if (inputFile != 0)
// If this is the first file then we already have the loaders loaded.
// Update the transient digit that is already in the fTDList by adding the new
// transient digits charges and track lists to the existing one.
- if (GetDebug() > 3)
- Info("UpdateTransientDigit", "Updating transient digit 0x%X", (void*)mTD);
+ AliDebug(4,Form( "Updating transient digit 0x%X", (void*)mTD));
// Choosing the maping of the cathode plane of the chamber:
Int_t iNchCpl= mTD->Chamber() + (mTD->Cathode()-1) * AliMUONConstants::NCh();
AliMUONTransientDigit *pdigit =
Int_t ntracks = mTD->GetNTracks();
if (ntracks > kMAXTRACKS) // Truncate the number of tracks to kMAXTRACKS if we have to.
{
- if (GetDebug() > 0)
- {
- Warning("UpdateTransientDigit",
- "TransientDigit returned the number of tracks to be %d, which is bigger than kMAXTRACKS.",
- ntracks);
- Warning("UpdateTransientDigit", "Reseting the number of tracks to be %d.", kMAXTRACKS);
- }
+ AliDebug(1,Form(
+ "TransientDigit returned the number of tracks to be %d, which is bigger than kMAXTRACKS.",
+ ntracks));
+ AliDebug(1,Form( "Reseting the number of tracks to be %d.", kMAXTRACKS));
ntracks = kMAXTRACKS;
};
// Adds the transient digit to the fTDList and sets the appropriate entry
// in the fHitMap arrays.
- if (GetDebug() > 3)
- Info("AddTransientDigit", "Adding transient digit 0x%X", (void*)mTD);
+ AliDebug(4,Form( "Adding transient digit 0x%X", (void*)mTD));
// Choosing the maping of the cathode plane of the chamber:
Int_t iNchCpl= mTD->Chamber() + (mTD->Cathode()-1) * AliMUONConstants::NCh();
fTDList->AddAtAndExpand(mTD, fTDCounter);
// Loops over the fTDList for each cathode, gets the correct signal for the
// digit and adds the new digit to the output stream.
- if (GetDebug() > 1) Info("CreateDigits", "Creating digits...");
+ AliDebug(2, "Creating digits...");
for (Int_t icat = 0; icat < 2; icat++)
{
//
// of digits from both cathodes.
if (icat != td->Cathode() - 1) continue;
- if (GetDebug() > 2)
- Info("CreateDigits", "Creating digit from transient digit 0x%X", (void*)td);
+ AliDebug(3,Form( "Creating digit from transient digit 0x%X", (void*)td));
Int_t q = GetSignalFrom(td);
if (q > 0) AddDigit(td, q);
Int_t nptracks = td->GetNTracks();
if (nptracks > kMAXTRACKS)
{
- if (GetDebug() > 0)
- {
- Warning("AddDigit",
- "TransientDigit returned the number of tracks to be %d, which is bigger than kMAXTRACKS.",
- nptracks);
- Warning("AddDigit", "Reseting the number of tracks to be %d.", kMAXTRACKS);
- }
+ AliDebug(1, Form(
+ "TransientDigit returned the number of tracks to be %d, which is bigger than kMAXTRACKS.",
+ nptracks));
+ AliDebug(1, Form("Reseting the number of tracks to be %d.", kMAXTRACKS));
nptracks = kMAXTRACKS;
};
};
};
- if (GetDebug() > 3) Info("AddDigit", "Adding digit with charge %d.", responseCharge);
+ AliDebug(4,Form( "Adding digit with charge %d.", responseCharge));
OnWriteTransientDigit(td);
AddDigit(td->Chamber(), tracks, charges, digits);
// The muon loader is then loaded from the fetched run loader.
// kTRUE is returned if no error occurred otherwise kFALSE is returned.
- if (GetDebug() > 2)
- Info("FetchLoaders", "Fetching run loader and muon loader from folder: %s", foldername);
+ AliDebug(3, Form("Fetching run loader and muon loader from folder: %s", foldername));
runloader = AliRunLoader::GetRunLoader(foldername);
if (runloader == NULL)
{
- Error("FetchLoaders", "RunLoader not found in folder: %s", foldername);
+ AliError(Form("RunLoader not found in folder: %s", foldername));
return kFALSE;
}
muonloader = (AliMUONLoader*) runloader->GetLoader("MUONLoader");
if (muonloader == NULL)
{
- Error("FetchLoaders", "MUONLoader not found in folder: %s", foldername);
+ AliError(Form("MUONLoader not found in folder: %s", foldername));
return kFALSE;
}
return kTRUE;
// AliMUONData fetched from the MUON module.
// kTRUE is returned if no error occurred otherwise kFALSE is returned.
- if (GetDebug() > 2)
- Info("FetchGlobalPointers", "Fetching gAlice, MUON module and AliMUONData from runloader 0x%X.",
+ AliDebug(3, Form("Fetching gAlice, MUON module and AliMUONData from runloader 0x%X.",
(void*)runloader
- );
+ ));
if (runloader->GetAliRun() == NULL) runloader->LoadgAlice();
gAlice = runloader->GetAliRun();
if (gAlice == NULL)
{
- Error("FetchGlobalPointers", "Could not find the AliRun object in runloader 0x%X.", (void*)runloader);
+ AliError(Form("Could not find the AliRun object in runloader 0x%X.", (void*)runloader));
return kFALSE;
};
fMUON = (AliMUON*) gAlice->GetDetector("MUON");
if (fMUON == NULL)
{
- Error("FetchGlobalPointers", "Could not find the MUON module in runloader 0x%X.", (void*)runloader);
+ AliError(Form("Could not find the MUON module in runloader 0x%X.", (void*)runloader));
return kFALSE;
};
AliMUONLoader *muonloader = (AliMUONLoader*) runloader->GetLoader("MUONLoader");
if (muonloader == NULL)
{
- Error("FetchGlobalPointers", "MUONLoader not found ");
+ AliError( "MUONLoader not found ");
return kFALSE;
}
if (fMUONData == NULL) fMUONData = new AliMUONData(muonloader,"MUON","MUON");
if (fMUONData == NULL)
{
- Error("FetchGlobalPointers", "Could not find AliMUONData object in runloader 0x%X.", (void*)runloader);
+ AliError(Form("Could not find AliMUONData object in runloader 0x%X.", (void*)runloader));
return kFALSE;
};
Bool_t AliMUONDigitizer::FetchTriggerPointer(AliMUONLoader* loader)
{
if (fMUONData == NULL) {
- Error("FetchTriggerPointer", "MUONData not found");
+ AliError("MUONData not found");
return kFALSE;
}
optionString.Data() == "deb" // maintained for compatability.
)
{
- Info("ParseOptions", "Called with option \"debug\".");
+ AliInfo("Called with option \"debug\".");
SetDebug(99);
};
};
//
// Note: the fTDList and fHitMap arrays must be NULL before calling this method.
- if (GetDebug() > 1) Info("InitArrays", "Initialising internal arrays.");
- if (GetDebug() > 3) Info("InitArrays", "Creating transient digits list.");
+ AliDebug(2, "Initialising internal arrays.");
+ AliDebug(4, "Creating transient digits list.");
fTDList = new TObjArray;
// Array of pointer of the AliMUONHitMapA1:
// Loop over chambers for the definition AliMUONHitMap
for (Int_t i = 0; i < AliMUONConstants::NCh(); i++)
{
- if (GetDebug() > 3) Info("InitArrays", "Creating hit map for chamber %d, cathode 1.", i+1);
+ AliDebug(4,Form( "Creating hit map for chamber %d, cathode 1.", i+1));
AliMUONChamber* chamber = &(fMUON->Chamber(i));
AliSegmentation* c1Segmentation = chamber->SegmentationModel(1); // Cathode plane 1
fHitMap[i] = new AliMUONHitMapA1(c1Segmentation, fTDList);
- if (GetDebug() > 3) Info("InitArrays", "Creating hit map for chamber %d, cathode 2.", i+1);
+ AliDebug(4,Form( "Creating hit map for chamber %d, cathode 2.", i+1));
AliSegmentation* c2Segmentation = chamber->SegmentationModel(2); // Cathode plane 2
fHitMap[i+AliMUONConstants::NCh()] = new AliMUONHitMapA1(c2Segmentation, fTDList);
};
{
// The arrays fTDList and fHitMap are deleted and the pointers set to NULL.
- if (GetDebug() > 1) Info("CleanupArrays", "Deleting internal arrays.");
+ AliDebug(2, "Deleting internal arrays.");
for(Int_t i = 0; i < 2*AliMUONConstants::NCh(); i++)
{
- if (GetDebug() > 3) Info("CleanupArrays", "Deleting hit map for chamber %d, cathode %d.",
- i%AliMUONConstants::NCh()+1, i/AliMUONConstants::NCh()+1);
+ AliDebug(4,Form( "Deleting hit map for chamber %d, cathode %d.",
+ i%AliMUONConstants::NCh()+1, i/AliMUONConstants::NCh()+1));
delete fHitMap[i];
};
delete [] fHitMap;
fHitMap = NULL;
- if (GetDebug() > 3) Info("CleanupArrays", "Deleting transient digits list.");
+ AliDebug(4, "Deleting transient digits list.");
fTDList->Delete();
delete fTDList;
fTDList = NULL;
#include "AliMUONHit.h"
#include "AliMUONTransientDigit.h"
#include "AliMUONTriggerDecision.h"
+#include "AliLog.h"
ClassImp(AliMUONDigitizerv1)
// Note: Charge correlation is applied to the tracking chambers.
TTree* treeH = fGime->TreeH();
- if (GetDebug() > 1)
- Info("GenerateTransientDigits", "Generating transient digits using treeH = 0x%X"
- , (void*)treeH);
+ AliDebug(2, Form("Generating transient digits using treeH = 0x%X"
+ , (void*)treeH));
//
// Loop over tracks
Int_t ntracks = (Int_t) treeH->GetEntries();
for (Int_t itrack = 0; itrack < ntracks; itrack++)
{
- if (GetDebug() > 2) Info("GenerateTransientDigits", "Processing track %d...", itrack);
+ AliDebug(3, Form("Processing track %d...", itrack));
fMUONData->ResetHits();
treeH->GetEvent(itrack);
//
Int_t ichamber = mHit->Chamber()-1; // chamber number
if (ichamber > AliMUONConstants::NCh()-1)
{
- Error("GenerateTransientDigits",
- "Hit 0x%X has a invalid chamber number: %d", ichamber);
+ AliError(Form("Hit 0x%X has a invalid chamber number: %d", ichamber));
continue;
}
//
//Dumping Hit content:
- if (GetDebug() > 2)
- {
- Info("GenerateTransientDigits",
- "Hit %d: chamber = %d\tX = %f\tY = %f\tZ = %f\teloss = %f",
+ AliDebug(3,Form("Hit %d: chamber = %d\tX = %f\tY = %f\tZ = %f\teloss = %f",
ihit, mHit->Chamber(), mHit->X(), mHit->Y(), mHit->Z(), mHit->Eloss()
- );
- }
+ ));
//
// Inititializing Correlation
AliMUONChamber& chamber = fMUON->Chamber(ichamber);
// fired for a given hit. We then loop over the fired pads and add an AliMUONTransientDigit
// for each pad.
- if (GetDebug() > 3)
- Info("MakeTransientDigitsFromHit", "Making transient digit for hit number %d.", iHit);
+ AliDebug(4,Form("Making transient digit for hit number %d.", iHit));
//
// Calls the charge disintegration method of the current chamber
- if (GetDebug() > 4)
- Info("MakeTransientDigitsFromHit", "Calling AliMUONChamber::DisIngtegration...");
+ AliDebug(5,"Calling AliMUONChamber::DisIngtegration...");
Float_t newdigit[6][500]; // Pad information
Int_t nnew=0; // Number of touched Pads per hit
};
digits[5] = iHit+fMask; // Hit number in the list
- if (GetDebug() > 4)
- Info("MakeTransientDigitsFromHit",
+ AliDebug(5,Form("MakeTransientDigitsFromHit",
"DisIntegration result %d: PadX %d\tPadY %d\tPlane %d\tCharge %d\tHit %d",
- iTD, digits[0], digits[1], digits[2], digits[3], digits[5]);
+ iTD, digits[0], digits[1], digits[2], digits[3], digits[5]));
AliMUONTransientDigit* mTD = new AliMUONTransientDigit(ichamber, digits);
mTD->AddToTrackList(track + fMask, charge);
{
// Derived to fill TreeD and resets the trigger array in fMUONData.
- if (GetDebug() > 2) Info("FillTriggerOutput", "Filling trees with trigger.");
+ AliDebug(3,"Filling trees with trigger.");
fMUONData->Fill("GLT");
fMUONData->ResetTrigger();
};
// Derived to apply the chamber response model to the digit.
// Using AliMUONChamber::ResponseModel() for this.
- if (GetDebug() > 3)
- Info("GetSignalFrom", "Applying response of chamber to TransientDigit signal.");
+ AliDebug(4, "Applying response of chamber to TransientDigit signal.");
//
// Digit Response (noise, threshold, saturation, ...)
Int_t q = td->Signal();
// Derived to initialize the output digits tree TreeD, create it if necessary
// and sets the fMUONData tree address to treeD.
- if (GetDebug() > 2)
- Info("InitOutputData", "Creating digits branch and setting the tree address.");
+ AliDebug(3, "Creating digits branch and setting the tree address.");
fMUONData->SetLoader(muonloader);
muonloader->MakeDigitsContainer();
if (muonloader->TreeD() == NULL)
{
- Error("InitOutputData", "Could not create TreeD.");
+ AliError("Could not create TreeD.");
return kFALSE;
};
};
{
// Derived to fill TreeD and resets the digit array in fMUONData.
- if (GetDebug() > 2) Info("FillOutputData", "Filling trees with digits.");
+ AliDebug(3, "Filling trees with digits.");
fMUONData->Fill("D");
fMUONData->ResetDigits();
};
{
// Derived to write the digits tree and then unload the digits tree once written.
- if (GetDebug() > 2) Info("CleanupOutputData", "Writing digits and releasing pointers.");
+ AliDebug(3, "Writing digits and releasing pointers.");
muonloader->WriteDigits("OVERWRITE");
muonloader->UnloadDigits();
};
// Derived to initialise the input to read from TreeH the hits tree.
// If the hits are not loaded then we load the hits using the muon loader.
- if (GetDebug() > 2)
- Info("InitInputData", "Loading hits in READ mode and setting the tree address.");
+ AliDebug(3, "Loading hits in READ mode and setting the tree address.");
fMUONData->SetLoader(muonloader);
muonloader->LoadHits("READ");
if (muonloader->TreeH() == NULL)
{
- Error("InitInputData", "Can not load the hits tree.");
+ AliError("Can not load the hits tree.");
return kFALSE;
};
};
{
// Derived to release the loaded hits and unload them.
- if (GetDebug() > 2) Info("CleanupInputData", "Releasing loaded hits.");
+ AliDebug(3, "Releasing loaded hits.");
fMUONData->ResetHits();
muonloader->UnloadHits();
};
#include "AliMUONDigit.h"
#include "AliMUONDigitizerv2.h"
#include "AliMUONTransientDigit.h"
+#include "AliLog.h"
ClassImp(AliMUONDigitizerv2)
// Loop over all chambers and s-digits in the input stream and create
// AliMUONTransientDigit objects from them. These are then added to fTDList.
- if (GetDebug() > 1)
- Info("GenerateTransientDigits", "Generating transient digits using treeH = 0x%X");
-
+ AliDebug(2,"Generating transient digits using treeH = 0x%X");
//
// Loop over SDigits
Int_t ndig, k;
// Makes a transient digit from the specified s-digit from the specified chamber.
// Once the digit is created it is added to the fTDList.
- if (GetDebug() > 3)
- Info("MakeTransientDigitFromSDigit",
- "Making transient digit from s-digit for chamber %d.", iChamber);
-
+ AliDebug(4,Form("Making transient digit from s-digit for chamber %d.", iChamber));
Int_t digits[6];
//
// Creating a new TransientDigits from SDigit
digits[5] = sDigit->Hit(); // Hit number in the list
- if (GetDebug() > 4)
- Info("MakeTransientDigitFromSDigit",
- "Made digit from sDigit 0x%X: PadX %d\tPadY %d\tPlane %d\tCharge %d\tHit %d",
- (void*)sDigit, digits[0], digits[1], digits[2], digits[3], digits[5]);
+ AliDebug(5,Form("Made digit from sDigit 0x%X: PadX %d\tPadY %d\tPlane %d\tCharge %d\tHit %d",
+ (void*)sDigit, digits[0], digits[1], digits[2], digits[3], digits[5]));
AliMUONTransientDigit* mTD = new AliMUONTransientDigit(iChamber, digits);
// Copy list of tracks and trackcharge
// If the s-digits are not loaded then the muon loader is used to load the
// s-digits into memory.
- if (GetDebug() > 2)
- Info("InitInputData", "Loading s-digits in READ mode and setting the tree address.");
-
+ AliDebug(3,"Loading s-digits in READ mode and setting the tree address.");
fMUONData->SetLoader(muonloader);
if (muonloader->TreeS() == NULL)
muonloader->LoadSDigits("READ");
if (muonloader->TreeS() == NULL)
{
- Error("InitInputData", "Can not load the s-digits tree.");
+ AliError("Can not load the s-digits tree.");
return kFALSE;
};
};
{
// Overridden to release and unload s-digits from memory.
- if (GetDebug() > 2) Info("CleanupInputData", "Releasing loaded s-digits.");
+ AliDebug(3,"Releasing loaded s-digits.");
fMUONData->ResetSDigits();
muonloader->UnloadSDigits();
};
#include "AliMUONChamber.h"
#include "AliMUONConstants.h"
#include "AliMC.h"
+#include "AliLog.h"
// to manage the same zoom on both cathodes
{
// Protected copy constructor
- Fatal("AliMUONDisplay", "Not implemented.");
+ AliFatal("Not implemented.");
}
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
#include "AliLoader.h"
#include "AliMUONTrackK.h" //AZ
#include "AliMC.h"
+#include "AliLog.h"
//************* Defaults parameters for reconstruction
const Double_t AliMUONEventReconstructor::fgkDefaultMinBendingMomentum = 3.0;
{
// Protected copy constructor
- Fatal("AliMUONEventReconstructor", "Not implemented.");
+ AliFatal("Not implemented.");
}
AliMUONEventReconstructor &
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
sprintf(treeName, "TreeK%d", fBkgGeantEventNumber);
fBkgGeantTK = (TTree*)gDirectory->Get(treeName);
if (!fBkgGeantTK) {
- cout << "ERROR: cannot find Kine Tree for background event: " <<
- fBkgGeantEventNumber << endl;
- exit(0);
+ AliError(Form("cannot find Kine Tree for background event: %d",fBkgGeantEventNumber));
+ exit(0);
}
}
if (fBkgGeantTK)
sprintf(treeName, "TreeH%d", fBkgGeantEventNumber);
fBkgGeantTH = (TTree*)gDirectory->Get(treeName);
if (!fBkgGeantTH) {
- cout << "ERROR: cannot find Hits Tree for background event: " <<
- fBkgGeantEventNumber << endl;
+ AliError(Form("cannot find Hits Tree for background event: %d",fBkgGeantEventNumber));
exit(0);
}
if (fBkgGeantTH && fBkgGeantHits) {
Int_t retval = fLoader->LoadHits();
if ( retval)
{
- Error("MakeEventToBeReconstructed","Error occured while loading hits.");
+ AliError("Error occured while loading hits.");
return;
}
treeH = fLoader->TreeH();
if (treeH == 0x0)
{
- Error("MakeEventToBeReconstructed","Can not get TreeH");
+ AliError("Can not get TreeH");
return;
}
}
nTRentries = Int_t(TR->GetEntries());
if (nTRentries != 1) {
- cout << "Error in AliMUONEventReconstructor::AddHitsForRecFromRawClusters"
- << endl;
- cout << "nTRentries = " << nTRentries << " not equal to 1" << endl;
+ AliError(Form("nTRentries = %d not equal to 1 ",nTRentries));
exit(0);
}
fLoader->TreeR()->GetEvent(0); // only one entry
treeR->GetEvent(0); // only one entry
if (!(fMUONData->IsTriggerBranchesInTree())) {
- cout << "Warning in AliMUONEventReconstructor::MakeTriggerTracks"
- << endl;
- cout << "Trigger information is not avalaible, nTRentries = " << nTRentries << " not equal to 1" << endl;
+ AliWarning(Form("Trigger information is not avalaible, nTRentries = %d not equal to 1",nTRentries));
return kFALSE;
}
#include "AliMUONSegmentationSlatN.h"
#include "AliMUONSegmentationTriggerX.h"
#include "AliMUONSegmentationTriggerY.h"
+#include "AliLog.h"
ClassImp(AliMUONFactory)
{
// Protected copy constructor
- Fatal("AliMUONFactory", "Not implemented.");
+ AliFatal("Not implemented.");
}
//__________________________________________________________________________
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
BuildStation5();
BuildStation6();
}
- else {
- if(fMUON->GetDebug()) {
- printf("\nAliMUONFactory: --------AliMUONFactory------------------------------");
- printf("\nAliMUONFactory: Non default version of MUON selected ");
- printf("\nAliMUONFactory: You have to construct yourself the MUON elements !!");
- printf("\nAliMUONFactory: ----------------------------------------------------");
- }
- }
+ else
+ AliDebug(0,"Non default version of MUON selected. You have to construct yourself the MUON elements !!");
}
//__________________________________________________________________________
case 5: BuildStation5(); break;
case 6: BuildStation6(); break;
- default: Fatal("Build", "Wrong station number");
+ default: AliFatal("Wrong station number");
}
}
#include "AliMUONGeometryConstituent.h"
#include "AliMagF.h"
#include "AliRun.h"
+#include "AliLog.h"
ClassImp(AliMUONGeometryBuilder)
{
// copy constructor (not implemented)
- Fatal("AliMUONGeometryBuilder", "Copy constructor not provided.");
+ AliFatal("Copy constructor not provided.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &right) return *this;
- Fatal("operator =", "Assignement operator not provided.");
+ AliFatal("Assignement operator not provided.");
return *this;
}
// virtual envelope + nof constituents = 0
// => not allowed;
// empty virtual envelope has no sense
- Fatal("CreateGeometry", "Virtual envelope must have constituents.");
+ AliFatal("Virtual envelope must have constituents.");
return;
}
// non virtual envelope + nof constituents > 0
// => not allowed;
// use VMC to place constituents
- Fatal("CreateGeometry", "Non virtual envelope cannot have constituents.");
+ AliFatal("Non virtual envelope cannot have constituents.");
return;
}
#include <TGeoMatrix.h>
#include "AliMUONGeometryConstituent.h"
+#include "AliLog.h"
ClassImp(AliMUONGeometryConstituent)
const AliMUONGeometryConstituent& rhs)
: TNamed(rhs)
{
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
#include "AliMUONGeometryEnvelope.h"
#include "AliMUONGeometryConstituent.h"
+#include "AliLog.h"
ClassImp(AliMUONGeometryEnvelope)
const AliMUONGeometryEnvelope& rhs)
: TNamed(rhs)
{
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
#include "AliMUONGeometryTransformStore.h"
#include "AliMUONGeometryEnvelope.h"
#include "AliMUONConstants.h"
+#include "AliLog.h"
ClassImp(AliMUONGeometryEnvelopeStore)
AliMUONGeometryEnvelopeStore::AliMUONGeometryEnvelopeStore(const AliMUONGeometryEnvelopeStore& rhs)
: TObject(rhs)
{
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
const TGeoCombiTrans* kTransform = fDETransforms->Get(detElemId);
if (!kTransform) {
- Warning("AlignEnvelope", "Transformation not found.");
+ AliWarning("Transformation not found.");
return false;
};
// to the list of envelopes.
// ---
- if (fDebug) {
- cout << "... Adding ";
- if (!isVirtual) cout << " non-";
- cout << "virtual envelope " << name
- << " id " << id << endl;
- }
+ if (!isVirtual) AliDebug(1,Form("Adding non-virtual envelope %s id %d",name.Data(),id));
+// else AliDebug(1,Form("Adding virtual envelope %s id %d",name.Data(),id));
AliMUONGeometryEnvelope* envelope
= new AliMUONGeometryEnvelope(name, id, isVirtual, only);
#include <TObjString.h>
#include "AliMUONGeometrySVMap.h"
+#include "AliLog.h"
ClassImp(AliMUONGeometrySVMap)
AliMUONStringIntMap::AliMUONStringIntMap(const AliMUONStringIntMap& rhs)
: TObject(rhs)
{
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
Int_t second2 = Get(first);
if ( second2 > 0 ) {
- Error("Add", "%s is already present in the map", first.Data());
+ AliError(Form("%s is already present in the map", first.Data()));
return false;
}
AliMUONGeometrySVMap::AliMUONGeometrySVMap(const AliMUONGeometrySVMap& rhs)
: TObject(rhs)
{
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
#include <TObjString.h>
#include "AliMUONGeometryTransformStore.h"
+#include "AliLog.h"
ClassImp(AliMUONGeometryTransformStore)
const AliMUONGeometryTransformStore& rhs)
: TObject(rhs)
{
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
fDETransforms.AddAt(newTransform, GetDetElementIndex(detElemId));
}
else
- Warning("Add", "The aligned volume %s is already present",
- alignedVolume.Data());
+ AliWarning(Form("The aligned volume %s is already present",
+ alignedVolume.Data()));
}
//______________________________________________________________________________
if ( index >= 0 && index < fNofDetElems )
return (const TGeoCombiTrans*)fDETransforms.At(index);
else {
- Warning("Get","Index %d out of limits", index);
+ AliWarning(Form("Index %d out of limits", index));
return 0;
}
}
* 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 "AliMUONHitForRec.h"
#include "AliMUONRawCluster.h"
#include "AliMUONHit.h"
+#include "AliLog.h"
ClassImp(AliMUONHitForRec) // Class implementation in ROOT context
{
// Protected copy constructor
- Fatal("AliMUONHitForRec", "Not implemented.");
+ AliFatal( "Not implemented.");
}
//__________________________________________________________________________
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal( "Not implemented.");
return *this;
}
#include "AliMUONHitMapA1.h"
#include "AliSegmentation.h"
#include "AliMUONDigit.h"
+#include "AliLog.h"
ClassImp(AliMUONHitMapA1)
{
// Protected copy constructor
- Fatal("AliMUONHitMapA1", "Not implemented.");
+ AliFatal("Not implemented.");
}
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal( "Not implemented.");
return *this;
}
//AliRoot includes
#include "AliMUONLoader.h"
#include "AliMUONConstants.h"
+#include "AliLog.h"
ClassImp(AliMUONLoader)
//___________________________________________________________________
{
// Protected copy constructor
- Fatal("AliMUONLoader", "Not implemented.");
+ AliFatal("Not implemented.");
}
//_______________________________________________________________________________
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
#include <TError.h>
//#include <TTree.h>
//#include <TDirectory.h>
+#include "AliLog.h"
#include "AliMUONMerger.h"
#include "AliMUON.h"
{
// Protected copy constructor
- Fatal("AliMUONMergerModule", "Not implemented.");
+ Fatal("copy constructor","Not implemented.");
}
//------------------------------------------------------------------------
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-
/* $Id$ */
#include "AliMUONPadHit.h"
#include "AliMUON.h"
#include "AliMUONHit.h"
#include "AliMUONDigit.h"
+#include "AliLog.h"
ClassImp(AliMUONPoints)
{
// Protected copy constructor
- Fatal("AliMUONPoints", "Not implemented.");
+ AliFatal("Not implemented.");
}
//_____________________________________________________________________________
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
#include "AliMUONLocalTrigger.h"
#include "AliMUONGlobalTrigger.h"
+#include "AliLog.h"
const Int_t AliMUONRawData::fgkDefaultPrintLevel = 0;
{
// Protected copy constructor
- Fatal("AliMUONRawData", "Not implemented.");
+ AliFatal("Not implemented.");
}
//_______________________________________________________________________
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
}
if (!nEntries)
- Error("AliMUONRawData::WriteTriggerDDL","No Trigger information available");
+ AliError("No Trigger information available");
buffer = new Int_t [680]; // [16(local)*5 words + 4 words]*8(reg) + 8 words = 680
#include "AliMUONRawStream.h"
#include "AliRawReader.h"
+#include "AliLog.h"
ClassImp(AliMUONRawStream)
AliMUONRawStream::AliMUONRawStream(const AliMUONRawStream& stream) :
TObject(stream)
{
- Fatal("AliMUONRawStream", "copy constructor not implemented");
+ AliFatal("copy constructor not implemented");
}
AliMUONRawStream& AliMUONRawStream::operator = (const AliMUONRawStream&
/* stream */)
{
- Fatal("operator =", "assignment operator not implemented");
+ AliFatal("assignment operator not implemented");
return *this;
}
// read the next raw digit
// returns kFALSE if there is no digit left
- Fatal("Next","method not implemented for raw data input");
+ AliFatal("method not implemented for raw data input");
return kFALSE;
#include "AliMUONRecoEvent.h"
#include "AliMUONRecoTrack.h"
#include "AliMUONHit.h"
+#include "AliLog.h"
ClassImp(AliMUONRecoDisplay)
{
// Protected copy constructor
- Fatal("AliMUONRecoDisplay", "Not implemented.");
+ AliFatal("Not implemented.");
}
//-------------------------------------------------------------------
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
TFolder* topfold = (TFolder*)config->GetTopFolder();
if (topfold == 0x0)
{
- Error("Exec","Can not get Alice top folder");
+ AliError("Can not get Alice top folder");
return;
}
TString fmdfoldname(config->GetDataFolderName()+"/"+"MUON");
TFolder* fmdfold = (TFolder*)topfold->FindObject(fmdfoldname);
if (fmdfold == 0x0)
{
- Error("Exec","Can not get MUON folder");
+ AliError("Can not get MUON folder");
return;
}
TTree* treeH = dynamic_cast<TTree*>(fmdfold->FindObject("TreeH"));
if (treeH == 0x0)
{
- Error("Exec","Can not get TreeH");
+ AliError("Can not get TreeH");
return;
}
/******************************************************************/
#include "AliMUONTrackHit.h"
#include "AliRun.h"
#include "AliHeader.h"
+#include "AliLog.h"
ClassImp(AliMUONRecoEvent)
{
// Protected copy constructor
- Fatal("AliMUONRecoEventModule", "Not implemented.");
+ AliFatal("Not implemented.");
}
//-------------------------------------------------------------------
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
fPosY[chamber] = y;
fPosZ[chamber] = z;
}
+
//-------------------------------------------------------------------
void AliMUONRecoTrack::TrackInfo()
{
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-
/* $Id$ */
///////////////////////////////////////////////////////////////////////////////
#include "AliMUONResponseV0.h"
#include "AliSegmentation.h"
+
ClassImp(AliMUONResponseV0)
//__________________________________________________________________________
#include "AliMUONData.h"
#include "AliMUONDigit.h"
#include "AliMUONTransientDigit.h"
+#include "AliLog.h"
ClassImp(AliMUONSDigitizerv1)
Int_t AliMUONSDigitizerv1::GetSignalFrom(AliMUONTransientDigit* td)
{
// Returns the transient digit signal as is without applying the chamber response.
-
- if (GetDebug() > 3) Info("GetSignalFrom", "Returning TransientDigit signal.");
+ AliDebug(4,"Returning TransientDigit signal.");
return td->Signal();
};
Bool_t AliMUONSDigitizerv1::InitOutputData(AliMUONLoader* muonloader)
{
// Overridden to initialise the output tree to be TreeS rather than TreeD.
-
- if (GetDebug() > 2)
- Info("InitOutputData", "Creating s-digits branch and setting the tree address.");
+ AliDebug(3,"Creating s-digits branch and setting the tree address.");
fMUONData->SetLoader(muonloader);
muonloader->MakeSDigitsContainer();
if (muonloader->TreeS() == NULL)
{
- Error("InitOutputData", "Could not create TreeS.");
+ AliError("Could not create TreeS.");
return kFALSE;
};
};
{
// Overridden to fill TreeS rather than TreeD.
- if (GetDebug() > 2) Info("FillOutputData", "Filling trees with s-digits.");
+ AliDebug(3,"Filling trees with s-digits.");
fMUONData->Fill("S");
fMUONData->ResetSDigits();
};
void AliMUONSDigitizerv1::CleanupOutputData(AliMUONLoader* muonloader)
{
// Overridden to write and then cleanup TreeS that was initialised in InitOutputData.
-
- if (GetDebug() > 2) Info("CleanupOutputData", "Writing s-digits and releasing pointers.");
+ AliDebug(3,"Writing s-digits and releasing pointers.");
muonloader->WriteSDigits("OVERWRITE");
fMUONData->ResetSDigits();
muonloader->UnloadSDigits();
#include "AliMUONHitForRec.h"
#include "AliMUONTrackParam.h"
#include "AliRun.h" // for gAlice
+#include "AliLog.h"
ClassImp(AliMUONSegment) // Class implementation in ROOT context
{
// Protected copy constructor
- Fatal("AliMUONSegment", "Not implemented.");
+ AliFatal("Not implemented.");
}
AliMUONSegment & AliMUONSegment::operator=(const AliMUONSegment& rhs)
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
#include <TString.h>
#include "AliMUONSegmentIndex.h"
+#include "AliLog.h"
//___________________________________________
ClassImp(AliMUONSegmentIndex)
void AliMUONSegmentIndex::Print() const
{
// Printing information of AliMUONSegmentIndex
- Info("Print", "Name=%s Id=%d PadX=%d PadY=%d Cathode=%d\n",fName.Data(),fChannelId,fPadX,fPadY,fCathode);
+ AliInfo(Form("Name=%s Id=%d PadX=%d PadY=%d Cathode=%d\n",fName.Data(),fChannelId,fPadX,fPadY,fCathode));
}
#include <TString.h>
#include "AliMUONSegmentManuIndex.h"
+#include "AliLog.h"
//___________________________________________
ClassImp(AliMUONSegmentManuIndex)
void AliMUONSegmentManuIndex::Print() const
{
// Printing AliMUONSegmentManuIndex information
- Info("Print","Name=%s Id=%d BusPatch=%d ManuId=%d ManuChannelId=%d\n",fName.Data(),fChannelId,fBusPatchId,fManuId,fManuChannelId);
+ AliInfo(Form("Name=%s Id=%d BusPatch=%d ManuId=%d ManuChannelId=%d\n",fName.Data(),fChannelId,fBusPatchId,fManuId,fManuChannelId));
}
#include <TMath.h>
#include "AliMUONSegmentPosition.h"
+#include "AliLog.h"
//___________________________________________
ClassImp(AliMUONSegmentPosition)
void AliMUONSegmentPosition::Print() const
{
// Printing AliMUONSegmentManuIndex information
- Info("Print","Name=%s Id=%d X=%f Y=%f Cathode=%d\n",fName.Data(),fChannelId, fX, fY,fCathode);
+ AliInfo(Form("Name=%s Id=%d X=%f Y=%f Cathode=%d\n",fName.Data(),fChannelId, fX, fY,fCathode));
}
#include "AliMUONSegmentManuIndex.h"
#include "AliMUONSegmentPosition.h"
#include "AliMUONSegmentIndex.h"
+#include "AliLog.h"
//___________________________________________
ClassImp(AliMUONSegmentationDetectionElement)
{
// Protected copy constructor
- Fatal("AliMUONSegmentationDetectionElementModule", "Not implemented.");
+ AliFatal("Not implemented.");
}
//_________________________________________________
AliMUONSegmentationDetectionElement::~AliMUONSegmentationDetectionElement(){
}
}
if (!foundsegmentindex) {
- Warning("FindIndexFromPosition","Not found Index for position x=%5.2f y=%5.2f \n",x,y);
+ AliWarning(Form("Not found Index for position x=%5.2f y=%5.2f \n",x,y));
}
return foundsegmentindex;
}
// Getting AliMUONSegmentIndex from name of AliMUONSegmentManuIndex
if (fMapManuIndexIndex) return (AliMUONSegmentIndex*) fMapManuIndexIndex->GetValue(SegmentManuIndexName);
else {
- Warning("GetIndex","SegmentManuIndex %s out of DetectionElement Mapping %s",
- SegmentManuIndexName,fDetectionElementType.Data());
+ AliWarning(Form("SegmentManuIndex %s out of DetectionElement Mapping %s",
+ SegmentManuIndexName,fDetectionElementType.Data()));
return 0x0;
}
}
// Getting ManuIndex from manuname
if (fMapIndexManuIndex) return (AliMUONSegmentManuIndex*) fMapIndexManuIndex->GetValue(SegmentIndexName);
else {
- Warning("GetManuIndex","SegmentIndex %s out of Detection Element mapping %s",
- SegmentIndexName,fDetectionElementType.Data());
+ AliWarning(Form("SegmentIndex %s out of Detection Element mapping %s",
+ SegmentIndexName,fDetectionElementType.Data()));
return 0x0;
}
}
pady = segmentindex->GetPadY();
}
else {
- Warning("GetPadI","Not found Index for position x=%5.2f y=%5.2f \n",x,y);
+ AliWarning(Form("Not found Index for position x=%5.2f y=%5.2f \n",x,y));
}
}
//_________________________________________________
// Getting position from indexname
if (fMapIndexPosition) return (AliMUONSegmentPosition*) fMapIndexPosition->GetValue(SegmentIndexName);
else {
- Warning("GetPosition","SegmentIndex %s out of DetectionElement mapping %s",
- SegmentIndexName, fDetectionElementType.Data());
+ AliWarning(Form("SegmentIndex %s out of DetectionElement mapping %s",
+ SegmentIndexName, fDetectionElementType.Data()));
return 0x0;
}
}
// Getting index form positionname
if (fMapPositionIndex) return (AliMUONSegmentIndex*) fMapPositionIndex->GetValue(PositionName);
else {
- Warning("GetIndexFromPosition","SegmentPosition %s out of DetectionElement Mapping %s",
- PositionName,fDetectionElementType.Data());
+ AliWarning(Form("SegmentPosition %s out of DetectionElement Mapping %s",
+ PositionName,fDetectionElementType.Data()));
return 0x0;
}
}
// Getting AliMUONSegmentManuIndex objecto from manu index
if (fMapManuIndexIndex) return (AliMUONSegmentManuIndex*) fMapManuIndexIndex->FindObject(ManuIndexName);
else {
- Warning("FindManuIndex","SegmentManuIndex %s out of DetectionElement mapping %s",
- ManuIndexName,fDetectionElementType.Data());
+ AliWarning(Form("SegmentManuIndex %s out of DetectionElement mapping %s",
+ ManuIndexName,fDetectionElementType.Data()));
return 0x0;
}
}
// Getting
if (fMapIndexPosition) return (AliMUONSegmentIndex *) fMapIndexPosition->FindObject(IndexName);
else {
- Warning("FindIndex","SegmentIndex %s out of DetectionElement mapping %s",
- IndexName,fDetectionElementType.Data());
+ AliWarning(Form("SegmentIndex %s out of DetectionElement mapping %s",
+ IndexName,fDetectionElementType.Data()));
return 0x0;
}
}
Int_t icathode;
//Bendingplane
icathode=0;
- Info("ReadingSegmentationMappingFile","%s", fSegmentationMappingFileBending.Data());
+ AliInfo(Form("%s", fSegmentationMappingFileBending.Data()));
ReadingSegmentationMappingFile(fSegmentationMappingFileBending ,icathode);
//NonBendingplane
icathode=1;
- Info("Init","Reading mapping file is %s\n", fSegmentationMappingFileNonBending.Data());
+ AliInfo(Form("Reading mapping file is %s\n", fSegmentationMappingFileNonBending.Data()));
ReadingSegmentationMappingFile(fSegmentationMappingFileNonBending,icathode);
}
{
ifstream in( infile, ios::in);
if (!in) {
- Error("ReadingSegmentationMappingFile", "File not found.");
+ AliError("File not found.");
}
else {
Int_t id, ix, iy, idmanu, idchannel;
#include "AliMUONChamber.h"
#include "AliRun.h"
#include "AliMUONConstants.h"
+#include "AliLog.h"
//___________________________________________
ClassImp(AliMUONSegmentationSlat)
{
// Protected copy constructor
- Fatal("AliMUONSegmentationSlatModule", "Not implemented.");
+ AliFatal("Not implemented.");
}
AliMUONSegmentationSlat::~AliMUONSegmentationSlat(){
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
#include <TArrayF.h>
#include "AliMUONSegmentationSlatModule.h"
+#include "AliLog.h"
//___________________________________________
ClassImp(AliMUONSegmentationSlatModule)
{
// Protected copy constructor
- Fatal("AliMUONSegmentationSlatModule", "Not implemented.");
+ AliFatal("Not implemented.");
}
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
#include "AliRun.h"
#include "AliMUON.h"
#include "AliMUONChamber.h"
+#include "AliLog.h"
ClassImp(AliMUONSegmentationTrigger)
AliMUON *pMUON = (AliMUON *) gAlice->GetModule("MUON");
AliMUONChamber* iChamber=&(pMUON->Chamber(chamber));
- if(pMUON->GetDebug()>1) printf("%s: Initialize Trigger Chamber Module Geometry\n",ClassName());
+ AliDebug(2,"Initialize Trigger Chamber Module Geometry");
Float_t zPos=iChamber->Z();
Float_t z1Pos=AliMUONConstants::DefaultChamberZ(10); //cp changed
Float_t z1pm=z1PosPlus/z1PosMinus;
Float_t z1mp=z1PosMinus/z1PosPlus;
- if(pMUON->GetDebug()>1) printf("%s: fZscale = %f \n",ClassName(),fZscale);
-
+ AliDebug(2,Form("fZscale = %f ",fZscale));
// calculate yCmin and fYcmax
Int_t i;
for (i=62; i>=0; i--) {
#include "AliMUONTriggerConstants.h"
#include "AliMUONChamber.h"
#include "AliRun.h" // gAlice
+#include "AliLog.h"
ClassImp(AliMUONSegmentationTriggerX)
void AliMUONSegmentationTriggerX::Init(Int_t chamber)
{
// intialize X segmentation
- AliMUON *pMUON = (AliMUON *) gAlice->GetModule("MUON");
- if(pMUON->GetDebug()>1) printf("%s: Initialize Trigger Chamber Geometry X\n",ClassName());
+ AliDebug(2,"Initialize Trigger Chamber Geometry X");
AliMUONSegmentationTrigger::Init(chamber);
// calculate x & y position of X strips
#include "AliMUONTriggerConstants.h"
#include "AliMUON.h"
#include "AliRun.h"
+#include "AliLog.h"
ClassImp(AliMUONSegmentationTriggerY)
void AliMUONSegmentationTriggerY::Init(Int_t chamber)
{
// intialize Y segmentation
- AliMUON *pMUON = (AliMUON *) gAlice->GetModule("MUON");
- if(pMUON->GetDebug()>1) printf("%s: Initialize Trigger Chamber Geometry Y\n",ClassName());
+ AliDebug(2,"Initialize Trigger Chamber Geometry Y");
AliMUONSegmentationTrigger::Init(chamber);
// calculate x & y position of Y strips
#include "AliMUONChamber.h"
#include "AliRun.h"
#include "AliMUON.h"
+#include "AliLog.h"
ClassImp(AliMUONSegmentationV0)
{
// Protected copy constructor
- Fatal("AliMUONSegmentationV0", "Not implemented.");
+ AliFatal("Not implemented.");
}
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
#include "AliMUON.h"
#include "AliMUONChamber.h"
#include "AliRun.h"
+#include "AliLog.h"
{
// Protected copy constructor
- Fatal("AliMUONSegmentationV01", "Not implemented.");
+ AliFatal("Not implemented.");
}
AliMUONSegmentationV01::AliMUONSegmentationV01()
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
#include "AliMUONGeometryEnvelopeStore.h"
#include "AliMUONConstants.h"
#include "AliRun.h"
+#include "AliLog.h"
ClassImp(AliMUONSlatGeometryBuilder)
AliMUONSlatGeometryBuilder::AliMUONSlatGeometryBuilder(const AliMUONSlatGeometryBuilder& rhs)
: AliMUONVGeometryBuilder(rhs)
{
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
#include "AliMUONChamber.h"
#include "AliMUONChamberGeometry.h"
#include "AliMUONGeometryEnvelopeStore.h"
+#include "AliLog.h"
ClassImp(AliMUONSt1GeometryBuilder)
{
// Protected copy constructor
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
#include "AliMUONGeometryEnvelopeStore.h"
#include "AliRun.h"
#include "AliMagF.h"
+#include "AliLog.h"
ClassImp(AliMUONSt1GeometryBuilderV2)
{
// Dummy copy constructor
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
#include "AliMUONSt1IniReader.h"
#include "AliMUONSt1Decoder.h"
#include "AliMUONTransientDigit.h"
+#include "AliLog.h"
ClassImp(AliMUONSt1Response);
{
// Copy constructor
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//__________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
StringVector lst = decoder::SplitList(lstCpl[n],",");
// should have 2 elements
if (lst.size() != 2) {
- Warning("ReadIniFile","Bad pad definition");
+ AliWarning("Bad pad definition");
continue;
}
IntPairVector lst1 = decoder::DecodeListOfIntRanges(lst[0],";");
StringVector lst = decoder::SplitList(lstCpl[n],",");
// should have 2 elements
if (lst.size() != 2) {
- Warning("ReadIniFile","Bad pad definition");
+ AliWarning("Bad pad definition");
continue;
}
DoublePairVector lst1 = decoder::DecodeListOfFloatRanges(lst[0],";");
TString path = fgkTopDir + fgkDataDir ;
//read .ini file
if (gSystem->AccessPathName(path+fIniFileName[plane],kReadPermission)){
- Fatal("ReadIniFile",
- Form("Unable to Read the file %s",fIniFileName[plane].Data()));
+ AliFatal(Form("Unable to Read the file %s",fIniFileName[plane].Data()));
return;
}
fRegions.clear();
while ((el = static_cast<AliMUONSt1ElectronicElement*>(next()))){
rule->AddElement(el);
}
- } else Warning("ReadIniFile",Form("Can't find region named %s",value.c_str()));
+ } else AliWarning(Form("Can't find region named %s",value.c_str()));
}
}
for (itValue = vals.begin() ; itValue != vals.end(); ++itValue){
fDefaultParameters[plane][i]=param;
}
if (rule) rule->AddParameter(param);
- } else Warning("ReadIniFile",Form("Can't find parameter named %s",value.c_str()));
+ } else AliWarning(Form("Can't find parameter named %s",value.c_str()));
}
}
if (rule) fRulesList[plane].AddFirst(rule);
#include <TString.h>
#include "AliMUONSt1ResponseParameter.h"
+#include "AliLog.h"
ClassImp(AliMUONSt1ResponseParameter);
}
file.close();
} else {
- Warning("SetPedestal",Form("Can't read file %s",fileName.Data()));
+ AliWarning(Form("Can't read file %s",fileName.Data()));
SetPedestal(150.,10.);
}
}
}
file.close();
} else {
- Warning("SetNoise",Form("Can't read file %s",fileName.Data()));
+ AliWarning(Form("Can't read file %s",fileName.Data()));
SetNoise(150.,10.);
}
}
case kGauss : return gRandom->Gaus(param.gauss.mean,param.gauss.sigma);
case kFile : return param.values[GC];
}
- Fatal("Choose","No mode is given");
+ AliFatal("No mode is given");
return 0;
}
#include "AliMUONSt1ResponseRule.h"
#include "AliMUONSt1ElectronicElement.h"
#include "AliMUONSt1ResponseParameter.h"
-
ClassImp(AliMUONSt1ResponseRule);
//__________________________________________________________________________
#include "AliRun.h"
#include "AliMUON.h"
#include "AliMUONChamber.h"
+#include "AliLog.h"
ClassImp(AliMUONSt1Segmentation)
: AliSegmentation(rhs)
{
// Copy constructor
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
// Set pad size Dx*Dy
// ---
- Fatal("SetPadSize", "Not uniform pad size.");
+ AliFatal("Not uniform pad size.");
}
//______________________________________________________________________________
// Get pad size in x
// ---
- Fatal("Dpx", "Not uniform pad size.");
+ AliFatal( "Not uniform pad size.");
return 0.;
}
// Get pad size in y
// ---
- Fatal("Dpy", "Not uniform pad size.");
+ AliFatal("Not uniform pad size.");
return 0.;
}
AliMpPad pad = fPlaneSegmentation->PadByIndices(AliMpIntPair(iX, iY));
if (!pad.IsValid())
- Fatal("Distance2AndOffset", "Cannot locate pad.");
+ AliFatal("Cannot locate pad.");
return (pad.Position()*fgkLengthUnit - TVector2(x, y)).Mod2();
}
// (specific to LYON, but mandatory for display)
// ---
- Fatal("GetNParallelAndOffset", "Not yet implemented.");
+ AliFatal( "Not yet implemented.");
}
// (Called from AliMUON::BuildGeometry)
// ---
- Warning("Draw", "Not yet implemented.");
+ AliWarning("Not yet implemented.");
}
//______________________________________________________________________________
#include "AliMUONSt1SpecialMotif.h"
+
//__________________________________________________________________________
AliMUONSt1SpecialMotif::AliMUONSt1SpecialMotif(const TVector2& delta,
Double_t rotAngle)
#include "AliMUONChamber.h"
#include "AliMUONChamberGeometry.h"
#include "AliMUONGeometryEnvelopeStore.h"
+#include "AliLog.h"
ClassImp(AliMUONSt2GeometryBuilder)
{
// Protected copy constructor
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-
+
#include "AliMUONSubEventTracker.h"
ClassImp(AliMUONSubEventTracker)
#include "AliMUONSubEventTrigger.h"
+
ClassImp(AliMUONSubEventTrigger)
//___________________________________________
#include "AliMUONTrackHit.h"
#include "AliMUONHitForRec.h"
+#include "AliLog.h"
ClassImp(AliMUONTrackHit) // Class implementation in ROOT context
fNextTrackHitWithSameHitForRec = NULL;
Hit->SetNTrackHits(Hit->GetNTrackHits() + 1);
}
-
//__________________________________________________________________________
AliMUONTrackHit::~AliMUONTrackHit()
{
#include "AliMUONRawCluster.h"
#include "AliMUONTrackParam.h"
#include "AliRun.h"
+#include "AliLog.h"
//#include "AliMagF.h"
const Int_t AliMUONTrackK::fgkSize = 5;
{
// Protected copy constructor
- Fatal("AliMUONTrackK", "Not implemented.");
+ AliFatal("Not implemented.");
}
//__________________________________________________________________________
Int_t ifailWeight;
mnvertLocalK(&((*fWeight)(0,0)), fgkSize,fgkSize,fgkSize,ifailWeight);
} else {
- cout << " ***** Warning in EvalCovariance: Determinant fWeight=0:" << endl;
+ AliWarning(" Determinant fWeight=0:");
}
return;
}
Int_t ifailCov;
mnvertLocalK(&((*fCovariance)(0,0)), fgkSize,fgkSize,fgkSize,ifailCov);
} else {
- cout << " ***** Warning in WeightPropagation: Determinant fCovariance=0:" << endl;
+ AliWarning(" Determinant fCovariance=0:");
}
// Loop over parameters to find change of the initial vs propagated ones
Int_t ifailCov;
mnvertLocalK(&((*fCovariance)(0,0)), fgkSize,fgkSize,fgkSize,ifailCov);
} else {
- cout << " ***** Warning in FindPoint: Determinant fCovariance=0:" << endl;
+ AliWarning("Determinant fCovariance=0:");
}
//windowB = fgkNSigma*TMath::Sqrt((*fCovariance)(0,0)+sigmaB*sigmaB);
//windowNonB = fgkNSigma*TMath::Sqrt((*fCovariance)(1,1)+sigmaNonB*sigmaNonB);
Int_t ifailCov;
mnvertLocalK(&((*fCovariance)(0,0)), fgkSize,fgkSize,fgkSize,ifailCov);
} else {
- cout << " ***** Warning in FindPoint: Determinant fCovariance=0:" << endl;
+ AliWarning("Determinant fCovariance=0:");
}
}
y = hit->GetBendingCoor();
Int_t ifailWU;
mnvertLocalK(&((wu)(0,0)), fgkSize,fgkSize,fgkSize,ifailWU);
} else {
- cout << " ***** Warning in TryPoint: Determinant wu=0:" << endl;
+ AliWarning("Determinant wu=0:");
}
trackParTmp = TMatrixD(wu,TMatrixD::kMult,right);
Int_t ifailWeight;
mnvertLocalK(&((*fWeight)(0,0)), fgkSize,fgkSize,fgkSize,ifailWeight);
} else {
- cout << " ***** Warning in MSThin: Determinant fWeight=0:" << endl;
+ AliWarning("Determinant fWeight=0:");
}
cosAlph = TMath::Cos((*fTrackParNew)(2,0));
Int_t ifailCov;
mnvertLocalK(&((*fCovariance)(0,0)), fgkSize,fgkSize,fgkSize,ifailCov);
} else {
- cout << " ***** Warning in Branson: Determinant fCovariance=0:" << endl;
+ AliWarning("Determinant fCovariance=0:");
}
}
Int_t ifailCov;
mnvertLocalK(&((*fCovariance)(0,0)), fgkSize,fgkSize,fgkSize,ifailCov);
} else {
- cout << " ***** Warning in GoToVertex: Determinant fCovariance=0:" << endl;
+ AliWarning("Determinant fCovariance=0:" );
}
}
Int_t ifailCov;
mnvertLocalK(&((*fCovariance)(0,0)), fgkSize,fgkSize,fgkSize,ifailCov);
} else {
- cout << " ***** Warning in MSLine: Determinant fCovariance=0:" << endl;
+ AliWarning("Determinant fCovariance=0:" );
}
(*fCovariance)(0,0) += dl3*(dYdT*dYdT+dYdB*dYdB); // <yy>
Int_t ifailWeight;
mnvertLocalK(&((*fWeight)(0,0)), fgkSize,fgkSize,fgkSize,ifailWeight);
} else {
- cout << " ***** Warning in MSLine: Determinant fWeight=0:" << endl;
+ AliWarning("Determinant fWeight=0:");
}
}
#include "AliMUONChamber.h"
#include "AliRun.h"
#include "AliMagF.h"
+#include "AliLog.h"
ClassImp(AliMUONTrackParam) // Class implementation in ROOT context
if ((z1 > this->fZ) && (z2 > this->fZ)) {i1 = 0; i2 = 1;}
else if ((z1 < this->fZ) && (z2 < this->fZ)) {i1 = 1; i2 = 0;}
else {
- cout << "ERROR in AliMUONTrackParam::CreateExtrapSegmentInStation" << endl;
- cout << "Starting Z (" << this->fZ << ") in between z1 (" << z1 <<
- ") and z2 (" << z2 << ") of station(0..) " << Station << endl;
+ AliError(Form("Starting Z (%f) in between z1 (%f) and z2 (%f) of station(0..)%d",this->fZ,z1,z2,Station));
+// cout << "ERROR in AliMUONTrackParam::CreateExtrapSegmentInStation" << endl;
+// cout << "Starting Z (" << this->fZ << ") in between z1 (" << z1 <<
+// ") and z2 (" << z2 << ") of station(0..) " << Station << endl;
}
extZ[i1] = z1;
extZ[i2] = z2;
#include <TVector.h>
#include "AliMUONTransientDigit.h"
+#include "AliLog.h"
ClassImp(AliMUONTransientDigit)
{
// Protected copy constructor
- Fatal("AliMUONFTransientDigit", "Not implemented.");
+ AliFatal( "Not implemented.");
}
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
#include "AliSegmentation.h"
#include "AliMUONChamber.h"
#include "AliMUONConstants.h"
+#include "AliLog.h"
ClassImp(AliMUONTriggerCircuit)
{
// Protected copy constructor
- Fatal("AliMUONTriggerCircuit", "Not implemented.");
+ AliFatal("Not implemented.");
}
//----------------------------------------------------------------------
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
#include "AliRunLoader.h"
#include "AliLoader.h"
#include "AliRawReader.h" // for raw data
+#include "AliLog.h"
//----------------------------------------------------------------------
fLoader = loader;
// initialize container
- if (data == 0)
- Error("TriggerDecision","No MUONdata for trigger\n");
- else
+ if (data == 0){
+ AliError("No MUONdata for trigger");
+ }else{
fMUONData = data;
-
+ }
// Loading AliRun master
AliRunLoader* runloader = fLoader->GetRunLoader();
if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
{
// Protected copy constructor
- Fatal("AliMUONTriggerDecision", "Not implemented.");
+ AliFatal("Not implemented.");
}
//----------------------------------------------------------------------
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal("Not implemented.");
return *this;
}
TClonesArray *muonDigits = Digits(chamber-1);
Int_t ndigits = muonDigits->GetEntriesFast();
- if (fDebug>=3)
- printf("\nFound %d digits in %p %d \n", ndigits, (void*)muonDigits,chamber-1);
+ AliDebug(3,Form("Found %d digits in %p %d", ndigits, (void*)muonDigits,chamber-1));
AliMUONDigit *mdig;
Int_t ix=mdig->PadX();
Int_t iy=mdig->PadY();
cathode = mdig->Cathode() + 1;
- if (fDebug>=3)
- printf("cathode %d ix %d iy %d \n",cathode,ix,iy);
+ AliDebug(3,Form("cathode %d ix %d iy %d ",cathode,ix,iy));
// get the sum of the coded charge
// see coding convention in AliMUONChamberTrigger::DisIntegration
{
// call the Trigger Algorithm from raw data and fill TreeR
- Fatal("Trigger2Trigger","Trigger not implemented for raw data input");
+ AliFatal("Trigger not implemented for raw data input");
}
#include "AliMUONChamber.h"
#include "AliMUONChamberGeometry.h"
#include "AliMUONGeometryEnvelopeStore.h"
+#include "AliLog.h"
ClassImp(AliMUONTriggerGeometryBuilder)
{
// Protected copy constructor
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
#include "AliMUONTriggerCircuit.h"
#include "AliRun.h"
#include "AliMUON.h"
+#include "AliLog.h"
ClassImp(AliMUONTriggerLut)
{
// Protected copy constructor
- Fatal("AliMUONTriggerLut", "Not implemented.");
+ AliFatal("Not implemented.");
}
//----------------------------------------------------------------------
if (this == &rhs) return *this;
- Fatal("operator=", "Not implemented.");
+ AliFatal( "Not implemented.");
return *this;
}
#include "AliMUONGeometryEnvelope.h"
#include "AliMUONGeometryConstituent.h"
#include "AliMUONConstants.h"
+#include "AliLog.h"
ClassImp(AliMUONVGeometryBuilder)
{
// Protected copy constructor
- Fatal("Copy constructor",
- "Copy constructor is not implemented.");
+ AliFatal("Copy constructor is not implemented.");
}
//______________________________________________________________________________
// check assignement to self
if (this == &rhs) return *this;
- Fatal("operator=",
- "Assignment operator is not implemented.");
+ AliFatal("Assignment operator is not implemented.");
return *this;
}
// and map it to the detection element Id if it is a sensitive volume
// ---
- Warning("MapSV", "Not yet available");
+ AliWarning("Not yet available");
}
//______________________________________________________________________________
AliMUONChamber* chamber = GetChamber(chamberId);
if (!chamber) {
- Fatal("GetEnvelopes", "Chamber %d is not defined", chamberId);
+ AliFatal(Form("Chamber %d is not defined", chamberId));
return 0;
}
AliMUONChamber* chamber = GetChamber(chamberId);
if (!chamber) {
- Fatal("GetTransforms", "Chamber %d is not defined", chamberId);
+ AliFatal(Form("Chamber %d is not defined", chamberId));
return 0;
}
AliMUONChamber* chamber = GetChamber(chamberId);
if (!chamber) {
- Fatal("GetSVMap", "Chamber %d is not defined", chamberId);
+ AliFatal(Form("Chamber %d is not defined", chamberId));
return 0;
}
ifstream in(filePath, ios::in);
if (!in) {
cerr << filePath << endl;
- Fatal("ReadTransformations", "File not found.");
+ AliFatal("File not found.");
return false;
}
else if (key == TString("DE"))
key = ReadData2(in);
else {
- Fatal("ReadTransformations", "%s key not recognized", key.Data());
+ AliFatal(Form("%s key not recognized", key.Data()));
return false;
}
}
ifstream in(filePath, ios::in);
if (!in) {
cerr << filePath << endl;
- Fatal("ReadSVMap", "File not found.");
+ AliFatal("File not found.");
return false;
}
if (key == TString("SV"))
key = ReadData3(in);
else {
- Fatal("ReadSVMap", "%s key not recognized", key.Data());
+ AliFatal(Form("%s key not recognized", key.Data()));
return false;
}
}
ofstream out(filePath, ios::out);
if (!out) {
cerr << filePath << endl;
- Error("WriteTransformations", "File not found.");
+ AliError("File not found.");
return false;
}
#if !defined (__DECCXX)
ofstream out(filePath, ios::out);
if (!out) {
cerr << filePath << endl;
- Error("WriteTransformations", "File not found.");
+ AliError("File not found.");
return false;
}
#if !defined (__DECCXX)
//#include "chainalice2.h"
#include "AliMUONSegmentationV0.h"
//#include "AliMUONSegResV11.h"
+#include "AliLog.h"
ClassImp(AliMUONproto)
AliMUONproto::AliMUONproto()
: AliMUON()
{
- cout << "\n Calling AliMUONproto constructor..." << endl;
+ AliInfo(" Calling AliMUONproto constructor...");
//
//
ifstream inputFile("/home/alice/guernane/aliroot/pro/MUON/crped190.dat", ios::in);
if (inputFile.fail()) {
- cout << "Error opening file" << endl;
+ AliError("Error opening file");
exit(2);
}
#include "AliMagF.h"
#include "AliRun.h"
#include "AliMC.h"
+#include "AliLog.h"
ClassImp(AliMUONv1)
{
// copy constructor (not implemented)
- Fatal("AliMUONv1", "Copy constructor not provided.");
+ AliFatal("Copy constructor not provided.");
}
//___________________________________________
// check assignement to self
if (this == &right) return *this;
- Fatal("operator =", "Assignement operator not provided.");
+ AliFatal("Assignement operator not provided.");
return *this;
}
//
// Initialize Tracking Chambers
//
-
- if(fDebug) printf("\n%s: Start Init for version 1 - CPC chamber type\n\n",ClassName());
+ AliDebug(1,"Start Init for version 1 - CPC chamber type");
Int_t i;
for (i=0; i<AliMUONConstants::NCh(); i++) {
( (AliMUONChamber*) (*fChambers)[i])->Init();
// Initialize geometry
//
fGeometryBuilder->InitGeometry();
- if(fDebug) printf("\n%s: Finished Init for version 1 - CPC chamber type\n",ClassName());
+ AliDebug(1,"Finished Init for version 1 - CPC chamber type");
//cp
- if(fDebug) printf("\n%s: Start Init for Trigger Circuits\n",ClassName());
+ AliDebug(1,"Start Init for Trigger Circuits");
for (i=0; i<AliMUONConstants::NTriggerCircuit(); i++) {
( (AliMUONTriggerCircuit*) (*fTriggerCircuits)[i])->Init(i);
}
- if(fDebug) printf("%s: Finished Init for Trigger Circuits\n",ClassName());
+ AliDebug(1,"Finished Init for Trigger Circuits");
//cp
//
cerr << " global position: "
<< x << ", " << y << ", " << z
<< endl;
- Warning("StepManager", "DetElemId not identified.");
+ AliWarning("DetElemId not identified.");
}
// One hit per chamber
#include "AliMagF.h"
#include "AliRun.h"
#include "AliMC.h"
+#include "AliLog.h"
ClassImp(AliMUONv3)
{
// copy constructor (not implemented)
- Fatal("AliMUONv3", "Copy constructor not provided.");
+ AliFatal("Copy constructor not provided.");
}
//_____________________________________________________________________________
// check assignement to self
if (this == &right) return *this;
- Fatal("operator =", "Assignement operator not provided.");
+ AliFatal("Assignement operator not provided.");
return *this;
}
// Initialize Tracking Chambers
//
- if(fDebug) printf("\n%s: Start Init for version 1 - CPC chamber type\n\n",ClassName());
+ AliDebug(0,"Start Init for version 1 - CPC chamber type");
Int_t i;
for (i=0; i<AliMUONConstants::NCh(); i++) {
( (AliMUONChamber*) (*fChambers)[i])->Init();
((AliMUONChamber*)(*fChambers)[12])->GetGeometry()->SetSensitiveVolume("SG3A");
((AliMUONChamber*)(*fChambers)[13])->GetGeometry()->SetSensitiveVolume("SG4A");
- if(fDebug) printf("\n%s: Finished Init for version 1 - CPC chamber type\n",ClassName());
-
+ AliDebug(0,"Finished Init for version 1 - CPC chamber type");
//cp
- if(fDebug) printf("\n%s: Start Init for Trigger Circuits\n",ClassName());
+ AliDebug(0,"Start Init for Trigger Circuits");
for (i=0; i<AliMUONConstants::NTriggerCircuit(); i++) {
( (AliMUONTriggerCircuit*) (*fTriggerCircuits)[i])->Init(i);
}
- if(fDebug) printf("%s: Finished Init for Trigger Circuits\n",ClassName());
+ AliDebug(0,"Finished Init for Trigger Circuits");
//cp
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff