#include <TString.h>
ClassImp(AliEMCALCalibCoef)
-
+// ----------------------------------------------------------------------
AliEMCALCalibCoef::AliEMCALCalibCoef() : fAbsId(-1), fCc(-1), fECc(-1)
{
// default constructor
}
+
+// ----------------------------------------------------------------------
AliEMCALCalibCoef::AliEMCALCalibCoef(const Int_t id, const Double_t c, const Double_t ec) :
fAbsId(id), fCc(c), fECc(ec)
{
// Oct 16, 2007
}
-// ----------------------------------------------------------------------
+
ClassImp(AliEMCALCalibCoefs)
+// ----------------------------------------------------------------------
AliEMCALCalibCoefs::AliEMCALCalibCoefs() : TNamed("",""), fTable(0), fCurrentInd(0), fCalibMethod(0)
{
// default constructor
}
+// ----------------------------------------------------------------------
+AliEMCALCalibCoefs::AliEMCALCalibCoefs(const AliEMCALCalibCoefs& coefs)
+ : TNamed(coefs), fTable(coefs.fTable),
+ fCurrentInd(coefs.fCurrentInd), fCalibMethod(coefs.fCalibMethod)
+{
+ // copy constructor
+}
+
+// ----------------------------------------------------------------------
AliEMCALCalibCoefs::AliEMCALCalibCoefs(const char* name, const Int_t nrow) : TNamed(name,"table of cell information") , fTable(0), fCurrentInd(0), fCalibMethod(0)
{
// Oct 16, 2007
fTable = new TObjArray(nrow);
}
+// ----------------------------------------------------------------------
void AliEMCALCalibCoefs::AddAt(AliEMCALCalibCoef* r)
{
// Oct 16, 2007
fCurrentInd++;
}
+// ----------------------------------------------------------------------
AliEMCALCalibCoefs::~AliEMCALCalibCoefs()
{
// Destructor
}
}
+// ----------------------------------------------------------------------
AliEMCALCalibCoef* AliEMCALCalibCoefs::GetTable(Int_t i) const
{
// Oct 16, 2007
return (AliEMCALCalibCoef*)fTable->At(i);
}
-
+// ----------------------------------------------------------------------
// Get initial Calib Data from DB
AliEMCALCalibCoefs* AliEMCALCalibCoefs::GetCalibTableFromDb(const char *tn, AliEMCALCalibData **calData)
{
return tab;
}
+// ----------------------------------------------------------------------
TH1F* AliEMCALCalibCoefs::GetHistOfCalibTableFromDb(const char *tn)
{
// First SM only
return h;
}
+// ----------------------------------------------------------------------
AliEMCALCalibData* AliEMCALCalibCoefs::GetCalibTableForDb(const AliEMCALCalibCoefs *tab, const char* dbLocation,
const char* coment)
{
return caldata;
}
+// ----------------------------------------------------------------------
AliEMCALCalibCoef *AliEMCALCalibCoefs::GetRow(const int absId)
{
// Oct 16, 2007
return 0;
}
+// ----------------------------------------------------------------------
void AliEMCALCalibCoefs::PrintTable()
{
// Oct 16, 2007
for(int i=0; i<fTable->GetSize(); i++) PrintTable(i);
}
+// ----------------------------------------------------------------------
void AliEMCALCalibCoefs::PrintTable(const Int_t i)
{
// Oct 16, 2007
PrintRec(GetTable(i));
}
+// ----------------------------------------------------------------------
void AliEMCALCalibCoefs::PrintRec(AliEMCALCalibCoef* r)
{
// Oct 16, 2007
enum EEmcalCalibType {kMC, kEQUALIZATION, kMIP, kPI0}; // type of EMCAL calibrations
AliEMCALCalibCoefs(); // default constractor
+ AliEMCALCalibCoefs(const AliEMCALCalibCoefs& coefs); // copy constractor
AliEMCALCalibCoefs(const char* name, const Int_t nrow);
virtual ~AliEMCALCalibCoefs();
ClassImp(AliEMCALCell)
+//______________________________________________________________
AliEMCALCell::AliEMCALCell() :
TFolder(),
fParent(0),fLh(0),
fAbsId(0),fSupMod(0),fModule(0),fPhi(0),fEta(0),fPhiCell(0),fEtaCell(0),fCcIn(0),fCcOut(0),
fFun(0)
{
+ //default ctor
}
+//______________________________________________________________
+AliEMCALCell::AliEMCALCell(const AliEMCALCell& cell) :
+ TFolder(cell.GetName(),cell.GetTitle()),
+ fParent(cell.fParent),fLh(cell.fLh),
+ fAbsId(cell.fAbsId),fSupMod(cell.fSupMod),
+ fModule(cell.fModule),fPhi(cell.fPhi),
+ fEta(cell.fEta),fPhiCell(cell.fPhiCell),
+ fEtaCell(cell.fEtaCell),fCcIn(cell.fCcIn),
+ fCcOut(cell.fCcOut),fFun(cell.fFun)
+{
+ //copy ctor
+}
+
+//______________________________________________________________
AliEMCALCell::AliEMCALCell(const Int_t absId, const char* title) :
TFolder(Form("Cell%4.4i",absId),title),
fParent(0),fLh(0),
}
+//______________________________________________________________
AliEMCALCell::~AliEMCALCell()
{
// dtor
}
-//-------------------------------------------------------------------------------------
+//-------------------------------------------------------------------------------------
void AliEMCALCell::SetCCfromDB(AliEMCALCalibData *ccDb)
{
// Oct 15, 2007
u::AddToNameAndTitle(h, 0, Form(", cc %5.2f MeV", fCcIn*1.e+3));
}
+//______________________________________________________________
void AliEMCALCell::SetCCfromCCTable(AliEMCALCalibCoefs *t)
{
// Oct 15, 2007
u::AddToNameAndTitle(h, 0, Form(", cc %5.2f MeV", fCcIn*1.e+3));
}
+//______________________________________________________________
void AliEMCALCell::FillEffMass(const Double_t mgg)
{
u::FillH1(GetHists(), 0, mgg);
}
+//______________________________________________________________
void AliEMCALCell::FillCellNtuple(TNtuple *nt)
{
if(nt==0) return;
nt->Fill(fAbsId,fSupMod,fModule,fPhi,fEta,fPhiCell,fEtaCell,fCcIn,fCcOut);
}
+//______________________________________________________________
void AliEMCALCell::FitHist(TH1* h, const char* name, const char* opt)
{
// Oct 15, 2007
printf("<I> AliEMCALCell::FitHist : |%s| is ended \n\n", h->GetName());
}
+//______________________________________________________________
void AliEMCALCell::FitEffMassHist(const char* opt)
{
// Oct 15, 2007
printf(" %s | fCcIn %6.5f -> % 6.5f <- fCcOut \n", GetTitle(), fCcIn , fCcOut);
}
+//______________________________________________________________
void AliEMCALCell::PrintInfo()
{
// Oct 15, 2007
// if(f) f->Dump();
}
+//______________________________________________________________
TList* AliEMCALCell::BookHists()
{
// Oct 15, 2007
public:
- AliEMCALCell();
+ AliEMCALCell(); //default ctor
+ AliEMCALCell(const AliEMCALCell& cell); //copy ctor
AliEMCALCell(const Int_t absId, const char* title="EMCAL cell");
virtual ~AliEMCALCell();
+ AliEMCALCell & operator = (const AliEMCALCell & /*rvalue*/) {
+ // assignement operator requested by coding convention but not
+ // needed
+ Fatal("operator =", "not implemented");
+ return *this;
+ };
+
void SetCCfromDB(AliEMCALCalibData *ccDb); // obsolete
void SetCCfromCCTable(AliEMCALCalibCoefs *t);
ClassImp(AliEMCALCellIndexes)
+// ------------------------------------------------------------------------------
AliEMCALCellIndexes::AliEMCALCellIndexes() : fAbsId(-1), fNSupMod(-1), fNModule(-1), fNIphi(-1),
fNIeta(-1), fIPhi(-1), fIEta(-1), fIPhim(-1), fIEtam(-1)
{
}
+
ClassImp(AliEMCALCellInfo)
-// ------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
AliEMCALCellInfo::AliEMCALCellInfo() : TNamed("",""), fTable(0), fCurrentInd(0)
{
+ //default constructor
+}
+
+// ------------------------------------------------------------------------------
+AliEMCALCellInfo::AliEMCALCellInfo(const AliEMCALCellInfo& info)
+ : TNamed(info.GetName(),info.GetTitle()),
+ fTable(info.fTable), fCurrentInd(info.fCurrentInd)
+{
+ //copy constructor
}
+// ------------------------------------------------------------------------------
AliEMCALCellInfo::AliEMCALCellInfo(const char* name, const Int_t nrow) : TNamed(name,"table of cell information") , fTable(0), fCurrentInd(0)
{
fTable = new TObjArray(nrow);
}
+// ------------------------------------------------------------------------------
void AliEMCALCellInfo::AddAt(AliEMCALCellIndexes* r)
{
(*fTable)[fCurrentInd] = new AliEMCALCellIndexes(*r);
fCurrentInd++;
}
+// ------------------------------------------------------------------------------
AliEMCALCellInfo::~AliEMCALCellInfo()
{
if(fTable) {
}
}
+// ------------------------------------------------------------------------------
AliEMCALCellIndexes* AliEMCALCellInfo::GetTable(Int_t i) const
{
// Oct 16, 2007
return (AliEMCALCellIndexes*)fTable->At(i);
}
+// ------------------------------------------------------------------------------
void AliEMCALCellInfo::PrintTable(int ind1, int ind2) const
{
// Oct 16, 2007
}
}
-
+// ------------------------------------------------------------------------------
AliEMCALCellInfo *AliEMCALCellInfo::GetTableForGeometry(const char* geoName)
{
// Oct 16, 2007
return GetTableForGeometry(g);
}
+// ------------------------------------------------------------------------------
AliEMCALCellInfo *AliEMCALCellInfo::GetTableForGeometry(AliEMCALGeometry *g)
{
// Oct 16, 2007
// Aug 1, 2007; Corr. Sep 05
// cellInfo -> AliEMCALCellIndexes - Oct 15, 2007
+
class AliEMCALCellIndexes : public TObject {
// See AliEMCALGeometry
// Indexes information
class AliEMCALCellInfo : public TNamed {
public:
AliEMCALCellInfo(); // default constractor
+ AliEMCALCellInfo(const AliEMCALCellInfo& info); //copy constructor
AliEMCALCellInfo(const char* name, const Int_t nrow);
virtual ~AliEMCALCellInfo();
//AliEMCALGeometry* AliEMCALFolder::fGeometry = 0;
+//_____________________________________________________________
AliEMCALFolder::AliEMCALFolder() :
TFolder(),
fCounter(0), fGeometry(0), fNumOfCell(0), fLhists(0), fLofCells(0),fPi0SelPar(0),fCalibData(0),
fCellNtuple(0),fLobj(0)
{
+ //default constructor
}
+//_____________________________________________________________
+AliEMCALFolder::AliEMCALFolder(const AliEMCALFolder& folder) :
+ TFolder(folder.GetName(),folder.GetTitle()),
+ fCounter(folder.fCounter),
+ fGeometry(folder.fGeometry), fNumOfCell(folder.fNumOfCell),
+ fLhists(folder.fLhists), fLofCells(folder.fLofCells),
+ fPi0SelPar(folder.fPi0SelPar),fCalibData(folder.fCalibData),
+ fCellNtuple(folder.fCellNtuple),fLobj(folder.fLobj)
+{
+ //copy constructor
+}
+
+//_____________________________________________________________
AliEMCALFolder::AliEMCALFolder(const char* name, const char* title, Bool_t putToBrowser) :
TFolder(name,title),
fCounter(-1), fGeometry(0), fNumOfCell(0), fLhists(0), fLofCells(0),fPi0SelPar(0),fCalibData(0),
Init(putToBrowser);
}
+//_____________________________________________________________
AliEMCALFolder::AliEMCALFolder(const Int_t it, const char* title, Bool_t putToBrowser) :
TFolder(Form("%s_%2.2i", AliEMCALFolder::fgkBaseFolderName.Data(),it),title),
fCounter(it), fGeometry(0), fNumOfCell(0), fLhists(0), fLofCells(0),fPi0SelPar(0),fCalibData(0),
Init(putToBrowser);
}
+//_____________________________________________________________
AliEMCALFolder::~AliEMCALFolder()
{
// dtor
}
+//_____________________________________________________________
void AliEMCALFolder::Init(Bool_t putToBrowser)
{
// Initialize all data structure
if(putToBrowser) gROOT->GetListOfBrowsables()->Add(this); // for testing purpuse
}
+//_____________________________________________________________
AliEMCALSuperModule* AliEMCALFolder::GetSuperModule(const Int_t nm)
{
// Oct 15, 2007
return sm;
}
-
+//_____________________________________________________________
AliEMCALCell* AliEMCALFolder::GetCell(const Int_t absId)
{ // May 30, 2007
if(absId<0 || absId >= fNumOfCell) return 0;
else return fLofCells[absId];
}
+//_____________________________________________________________
void AliEMCALFolder::SetCell(AliEMCALCell *cell, const Int_t absId)
{
// Oct 15, 2007
}
}
+//_____________________________________________________________
AliEMCALPi0SelectionParRec* AliEMCALFolder::GetPi0SelectionParRow(Int_t nrow)
{
// Oct 15, 2007
return r;
}
+//_____________________________________________________________
void AliEMCALFolder::FillPi0Candidate(const Double_t mgg, AliESDCaloCluster* cl1, AliESDCaloCluster* cl2)
{
// Oct 15, 2007
}
}
+//_____________________________________________________________
void AliEMCALFolder::FillPi0Candidate(const Double_t mgg, Int_t absIdMax, Int_t nm)
{
// Jun 08
cell->FillEffMass(mgg);
}
+//_____________________________________________________________
void AliEMCALFolder::FitAllSMs()
{ // Jun 14, 2007
// Only first SM now - should be changed in the future
Add(ccOut);
}
+//_____________________________________________________________
AliEMCALCalibCoefs* AliEMCALFolder::GetCCTable(const char* name) const
{
// Oct 15, 2007
else return 0;
}
+//_____________________________________________________________
Int_t AliEMCALFolder::GetSMNumber(AliESDCaloCluster* cl)
{
// Oct 15, 2007
}
// Recalibration staf - Jun 18,2007
+//_____________________________________________________________
AliEMCALRecPoint* AliEMCALFolder::GetRecPoint(AliESDCaloCluster *cl, AliEMCALCalibCoefs *tOld,AliEMCALCalibCoefs *tNew,
TList *l, Double_t deff, Double_t w0, Double_t phiSlope)
{
return rp;
}
+//_____________________________________________________________
void AliEMCALFolder::Save(const char *fn, const char *opt)
{
//
if(fn || opt);
}
+//_____________________________________________________________
AliEMCALFolder* AliEMCALFolder::ReadFolder(const char *fn, const char *opt)
{
//
return emcal;
}
-
+//_____________________________________________________________
void AliEMCALFolder::InitAfterRead()
{
// Oct 15, 2007
}
}
+//_____________________________________________________________
void AliEMCALFolder::DrawQA(const int nsm)
{
//
c->Update();
}
+//_____________________________________________________________
TList* AliEMCALFolder::BookHists()
{
// Oct 15, 2007
return l;
}
+//_____________________________________________________________
void AliEMCALFolder::CreateCellNtuple()
{
// Jun 28, 2007
fLobj->Add(fCellNtuple);
}
+//_____________________________________________________________
void AliEMCALFolder::CreateAndFillAdditionalHists()
{
// Oct 15, 2007
h1->SetTitle("CC distribution after #pi^{0} calibration");
h1->SetXTitle(" MeV ");
h1->SetYTitle(" N ");
- TLatex *lat1 = u::Lat(Form("rel.width = %4.2f%%",
- 100.*h1->GetRMS()/ h1->GetMean()), 16.5, 100., 12, 0.045);
- TLatex *lat2 = u::Lat(Form("rel.width = %4.2f%% (from fit)",
- 100.*g->GetParameter(2)/ g->GetParameter(1)), 16.5, 70., 12, 0.045);
+ // TLatex *lat1 = u::Lat(Form("rel.width = %4.2f%%",
+ //100.*h1->GetRMS()/ h1->GetMean()), 16.5, 100., 12, 0.045);
+ //TLatex *lat2 = u::Lat(Form("rel.width = %4.2f%% (from fit)",
+ // 100.*g->GetParameter(2)/ g->GetParameter(1)), 16.5, 70., 12, 0.045);
if(0) {
TH1 *h2 = (TH1*)fLhists->At(2);
c->Update();
}
+//_____________________________________________________________
void AliEMCALFolder::TestSMStruct()
{
// testing May 22, 2007
public:
AliEMCALFolder();
+ AliEMCALFolder(const AliEMCALFolder& folder); //copy constructor
AliEMCALFolder(const char* name, const char* title="Top EMCAL folder", Bool_t putToBrowser=kFALSE);
AliEMCALFolder(const Int_t it, const char* title="Top EMCAL folder", Bool_t putToBrowser=kFALSE);
virtual ~AliEMCALFolder();
+ AliEMCALFolder & operator = (const AliEMCALFolder & /*rvalue*/) {
+ // assignement operator requested by coding convention but not
+ // needed
+ Fatal("operator =", "not implemented");
+ return *this;
+ };
+
void Init(Bool_t putToBrowser=kFALSE);
// Get methods
Int_t GetIterationNumber() const {return fCounter;}
if(fGeoName.Contains("HUGE")) fNECLayers *= 3; // 28-oct-05 for analysing leakage
}
}
- } else if(fGeoName.Contains("TRD2")) { // 30-jan-05
- fSteelFrontThick = 0.0; // 11-mar-05
- fIPDistance+= fSteelFrontThick; // 1-feb-05 - compensate absence of steel plate
- fTrd1Angle = 1.64; // 1.3->1.64
- fTrd2AngleY = fTrd1Angle; // symmetric case now
- fEmptySpace = 0.2; // 2 mm
- fTubsR = fIPDistance; // 31-jan-05 - as for Fred case
-
- fPhiModuleSize = fTubsR*2.*TMath::Tan(fTrd2AngleY*TMath::DegToRad()/2.);
- fPhiModuleSize -= fEmptySpace/2.; // 11-mar-05
- fEtaModuleSize = fPhiModuleSize; // 20-may-05
- fTubsTurnAngle = 3.;
}
fNPHIdiv = fNETAdiv = 2; // 13-oct-04 - division again
if(fGeoName.Contains("3X3")) { // 23-nov-04
// 30-sep-04
if(fGeoName.Contains("TRD")) {
f2Trd1Dx2 = fEtaModuleSize + 2.*fLongModuleSize*TMath::Tan(fTrd1Angle*TMath::DegToRad()/2.);
- if(fGeoName.Contains("TRD2")) { // 27-jan-05
- f2Trd2Dy2 = fPhiModuleSize + 2.*fLongModuleSize*TMath::Tan(fTrd2AngleY*TMath::DegToRad()/2.);
- }
}
} else Fatal("Init", "%s is an undefined geometry!", fGeoName.Data()) ;
if(fGeoName.Contains("TRD")) {
printf(" fTrd1Angle %7.4f\n", fTrd1Angle);
printf(" f2Trd1Dx2 %7.4f\n", f2Trd1Dx2);
- if(fGeoName.Contains("TRD2")) {
- printf(" fTrd2AngleY %7.4f\n", fTrd2AngleY);
- printf(" f2Trd2Dy2 %7.4f\n", f2Trd2Dy2);
- printf(" fTubsR %7.2f cm\n", fTubsR);
- printf(" fTubsTurnAngle %7.4f\n", fTubsTurnAngle);
- printf(" fEmptySpace %7.4f cm\n", fEmptySpace);
- } else if(fGeoName.Contains("TRD1")){
+ if(fGeoName.Contains("TRD1")){
printf("SM dimensions(TRD1) : dx %7.2f dy %7.2f dz %7.2f (SMOD, BOX)\n",
fParSM[0],fParSM[1],fParSM[2]);
printf(" fPhiGapForSM %7.4f cm (%7.4f <- phi size in degree)\n",
return trd1;
}
-void AliEMCALGeometry::Browse(TBrowser* b) const
+void AliEMCALGeometry::Browse(TBrowser* b)
{
//Browse the modules
if(fShishKebabTrd1Modules) b->Add(fShishKebabTrd1Modules);
static Char_t* GetDefaulGeometryName() {return fgDefaultGeometryName;}
void PrintGeometry(); //*MENU*
void PrintCellIndexes(Int_t absId=0, int pri=0, char *tit=""); //*MENU*
- virtual void Browse(TBrowser* b) const ;
+ virtual void Browse(TBrowser* b);
virtual Bool_t IsFolder() const;
void GetCellPhiEtaIndexInSModuleFromTRUIndex(Int_t itru, Int_t iphitru, Int_t ietatru, Int_t &ietaSM, Int_t &iphiSM) const ; // Tranforms Eta-Phi Cell index in TRU into Eta-Phi index in Super Module
#include "AliEMCALPi0SelectionParam.h"
ClassImp(AliEMCALPi0SelectionParRec)
+//_________________________________________________________________________
AliEMCALPi0SelectionParRec::AliEMCALPi0SelectionParRec() :
fEOfRpMin(0.3), fEOfRpMax(30.), fMassGGMin(0.03), fMassGGMax(0.28), fMomPi0Min(1.8), fMomPi0Max(12.)
{
// Default constructor
}
-//_________________________________________________________________________
+
+
+
ClassImp(AliEMCALPi0SelectionParam)
+//_________________________________________________________________________
AliEMCALPi0SelectionParam::AliEMCALPi0SelectionParam() : TNamed("",""), fTable(0), fCurrentInd(0)
{
// Default constructor
}
+//_________________________________________________________________________
+AliEMCALPi0SelectionParam::AliEMCALPi0SelectionParam(const AliEMCALPi0SelectionParam& param)
+ : TNamed(param), fTable(param.fTable), fCurrentInd(param.fCurrentInd)
+{
+ // Copy constructor
+}
+
+//_________________________________________________________________________
AliEMCALPi0SelectionParam::AliEMCALPi0SelectionParam(const char* name, const Int_t nrow) : TNamed(name,"table of cell information") , fTable(0), fCurrentInd(0)
{
// Oct 16, 2007
fTable = new TObjArray(nrow);
}
+//_________________________________________________________________________
void AliEMCALPi0SelectionParam::AddAt(AliEMCALPi0SelectionParRec* r)
{
// Oct 16, 2007
fCurrentInd++;
}
+//_________________________________________________________________________
AliEMCALPi0SelectionParam::~AliEMCALPi0SelectionParam()
{
// Oct 16, 2007
}
}
+//_________________________________________________________________________
AliEMCALPi0SelectionParRec* AliEMCALPi0SelectionParam::GetTable(Int_t i) const
{
// Oct 16, 2007
return (AliEMCALPi0SelectionParRec*)fTable->At(i);
}
+//_________________________________________________________________________
void AliEMCALPi0SelectionParam::PrintTable()
{
// Oct 16, 2007
for(int i=0; i<GetNRows(); i++) PrintTable(i);
}
+//_________________________________________________________________________
void AliEMCALPi0SelectionParam::PrintTable(const Int_t i)
{
// Oct 16, 2007
PrintRec(GetTable(i));
}
+//_________________________________________________________________________
void AliEMCALPi0SelectionParam::PrintRec(AliEMCALPi0SelectionParRec* r)
{
// Oct 16, 2007
printf(" gamma,gamma mass window %7.2f -> %7.2f \n", r->fMassGGMin, r->fMassGGMax);
printf(" pi0 momentum window %7.2f -> %7.2f \n", r->fMomPi0Min, r->fMomPi0Max);
}
+
+//_________________________________________________________________________
// Set 1;
AliEMCALPi0SelectionParam* AliEMCALPi0SelectionParam::Set1()
{
class AliEMCALPi0SelectionParam : public TNamed {
public:
AliEMCALPi0SelectionParam(); // default constractor
+ AliEMCALPi0SelectionParam(const AliEMCALPi0SelectionParam& param);
AliEMCALPi0SelectionParam(const char* name, const Int_t nrow);
virtual ~AliEMCALPi0SelectionParam();
}
void GetCenterOfCellInLocalCoordinateofSM_3X3(Int_t ieta, Double_t &xr, Double_t &zr) const
{ // 3X3 case - Nov 9,2006
- ieta = ieta<0? ieta=0 : ieta; // check index
- ieta = ieta>2? ieta=2 : ieta;
+ if(ieta < 0) ieta = 0;
+ if(ieta > 2) ieta = 2;
+ // ieta = ieta<0? ieta=0 : ieta; // check index
+ //ieta = ieta>2? ieta=2 : ieta;
xr = fOK3X3[2-ieta].Y();
zr = fOK3X3[2-ieta].X();
}
#include <TNode.h>
#include <TBRIK.h>
#include <TTRD1.h>
-#include <TTRD2.h>
#include <TTRAP.h>
#include <TPGON.h>
#include <TTUBS.h>
TNode * top = gAlice->GetGeometry()->GetNode("alice") ; // See AliceGeom/Nodes
TNode * envelopNode = 0;
char *envn = "Envelop1";
- if(!gn.Contains("SHISH") || gn.Contains("TRD2")){
+ if(!gn.Contains("SHISH")){
new TTUBS(envn, "Tubs that contains arm 1", "void",
geom->GetEnvelop(0) -10, // rmin
geom->GetEnvelop(1) +40 ,// rmax
// Create the EMCAL Mother Volume (a polygone) within which to place the Detector and named XEN1
Float_t envelopA[10];
- if(gn.Contains("TRD2")) { // TUBS
- envelopA[0] = geom->GetEnvelop(0) - 10.; // rmin
- envelopA[1] = geom->GetEnvelop(1) + 12.; // rmax
- // envelopA[2] = geom->ZFromEtaR(geom->GetEnvelop(1), geom->GetArm1EtaMin());
- envelopA[2] = 390.; // 6-feb-05
- envelopA[3] = geom->GetArm1PhiMin();
- envelopA[4] = geom->GetArm1PhiMax();
- gMC->Gsvolu("XEN1", "TUBS", fIdTmedArr[kIdAIR], envelopA, 5) ; // Tubs filled with air
- fEnvelop1.Set(5, envelopA);
- // Position the EMCAL Mother Volume (XEN1) in Alice (ALIC)
- gMC->Gspos("XEN1", 1, "ALIC", 0.0, 0.0, 0.0, fIdRotm, "ONLY") ;
- } else if(gn.Contains("TRD1") && gn.Contains("WSUC") ) { // TRD1 for WSUC facility
+ if(gn.Contains("TRD1") && gn.Contains("WSUC") ) { // TRD1 for WSUC facility
// 17-may-05 - just BOX
envelopA[0] = 26;
envelopA[1] = 15;
}
if(gn.Contains("SHISH")){
- // COMPACT, TWIST, TRD2 or TRD1
+ // COMPACT, TWIST, or TRD1
AliDebug(2,Form("Shish-Kebab geometry : %s", GetTitle()));
CreateShishKebabGeometry();
}
// 24-aug-04 by PAI
void AliEMCALv0::CreateShishKebabGeometry()
{
- // TWIST, TRD1 and TRD2
+ // TWIST, TRD1
AliEMCALGeometry * g = GetGeometry();
TString gn(g->GetName()); gn.ToUpper();
// see AliModule::fFIdTmedArr
} else if(g->GetNPHIdiv()==4 && g->GetNETAdiv()==4) {
Trd1Tower4X4();
}
- } else if(gn.Contains("TRD2")) { // TRD2 - 14-jan-05
- // Scm0InTrd2(g, fParEMOD, parSCM0); // First dessin
- PbmoInTrd2(g, fParEMOD, parSCM0); // Second design
}
}
{
// 18-may-05; mother="XEN1";
// child="SMOD" from first to 10th, "SM10" (11th and 12th) (TRD1 case)
- // child="SMON" and "SMOP"("TRD2" case)
AliEMCALGeometry * g = GetGeometry();
TString gn(g->GetName()); gn.ToUpper();
- Double_t par[3], parTubs[5], xpos=0., ypos=0., zpos=0., rpos=0., dphi=0., phi=0.0, phiRad=0.;
+ Double_t par[3], xpos=0., ypos=0., zpos=0., rpos=0., dphi=0., phi=0.0, phiRad=0.;
Double_t par1C = 0.;
// ===== define Super Module from air - 14x30 module ==== ;
fSampleWidth = double(g->GetECPbRadThick()+g->GetECScintThick());
AliDebug(2,Form(" rpos %8.2f : dphi %6.1f degree \n", rpos, dphi));
}
- if (gn.Contains("TRD2")) { // tubs - 27-jan-05
- parTubs[0] = g->GetTubsR(); // rmin
- parTubs[1] = parTubs[0] + g->GetShellThickness(); // rmax ??
- parTubs[2] = 380./2.; // DZ half length in z; 11-oct-04 - for 26 division
- parTubs[3] = -dphi/2.; // PHI1 starting angle of the segment;
- parTubs[4] = +dphi/2.; // PHI2 ending angle of the segment;
-
- gMC->Gsvolu("SMOP", "TUBS", fIdTmedArr[kIdAIR], parTubs, 5); // pozitive Z
- gMC->Gsvolu("SMON", "TUBS", fIdTmedArr[kIdAIR], parTubs, 5); // negative Z
-
- AliDebug(2,Form(" SMOP,N ** TUBS **\n"));
- AliDebug(2,Form("tmed %i | Rmin %7.2f Rmax %7.2f dz %7.2f phi1,2 (%7.2f,%7.2f)\n",
- fIdTmedArr[kIdAIR], parTubs[0],parTubs[1],parTubs[2], parTubs[3],parTubs[4]));
- // have to add 1 cm plastic before EMOD - time solution
- } else if(gn.Contains("WSUC")) {
+ if(gn.Contains("WSUC")) {
par[0] = g->GetPhiModuleSize()*g->GetNPhi()/2.;
par[1] = g->GetShellThickness()/2.;
par[2] = g->GetEtaModuleSize()*g->GetNZ()/2. + 5;
if(gn.Contains("TEST")) {nphism = 1;} // just only 2 super modules;
// Turn whole super module
- int turnSupMod = 1; // should be ONE; for testing = 0
for(int i=i0; i<nphism; i++) {
- if (gn.Contains("TRD2")) { // tubs - 27-jan-05
- if(i==i0) {
- printf("** TRD2 ** ");
- if(turnSupMod==1) printf(" No 3 degree rotation !!! ");
- printf("\n");
- }
- Double_t phic=0., phicRad=0.; // phi angle of arc center
- phic = g->GetArm1PhiMin() + dphi*(2*i+1)/2.; //
- phicRad = phic*TMath::DegToRad();
- phi = phic - g->GetTubsTurnAngle();
- phiRad = phi*TMath::DegToRad();
- if(turnSupMod==1) {
- TVector2 vc; // position of super module center
- vc.SetMagPhi(parTubs[0], phicRad);
- TVector2 vcTurn; // position of super module center with turn
- vcTurn.SetMagPhi(parTubs[0], phiRad);
- TVector2 vcShift = vc - vcTurn;
- phic = phi;
-
- xpos = vcShift.X();
- ypos = vcShift.Y();
- } else { // 1-mar-05 ; just for testing - no turn od SMOD; looks good
- xpos = ypos = 0.0;
- }
- zpos = parTubs[2];
- AliMatrix(fIdRotm, 90.0, phic, 90.0, 90.0+phic, 0.0, 0.0);
-
- gMC->Gspos("SMOP", ++nr, mother, xpos, ypos, zpos, fIdRotm, "ONLY") ;
- printf("SMOP %2i | %2i fIdRotm %3i phi %6.1f(%5.3f) xpos %7.2f ypos %7.2f zpos %7.2f \n",
- i, nr, fIdRotm, phic, phicRad, xpos, ypos, zpos);
- printf(" phiy(90+phic) %6.1f \n", 90. + phic);
-
- if(!gn.Contains("TEST1") && g->GetNumberOfSuperModules() > 1){
- // double phiy = 90. + phic + 180.;
- // if(phiy>=360.) phiy -= 360.;
- // printf(" phiy %6.1f \n", phiy);
- // AliMatrix(fIdRotm, 90.0, phic, 90.0, phiy, 180.0, 0.0);
- gMC->Gspos("SMON", nr, mother, xpos, ypos, -zpos, fIdRotm, "ONLY") ;
- printf("SMON %2i | %2i fIdRotm %3i phi %6.1f(%5.3f) xpos %7.2f ypos %7.2f zpos %7.2f \n",
- i, nr, fIdRotm, phic, phicRad, xpos, ypos, -zpos);
- }
- } else if(gn.Contains("WSUC")) {
+ if(gn.Contains("WSUC")) {
xpos = ypos = zpos = 0.0;
fIdRotm = 0;
gMC->Gspos("SMOD", 1, mother, xpos, ypos, zpos, fIdRotm, "ONLY") ;
AliEMCALGeometry * g = GetGeometry();
TString gn(g->GetName()); gn.ToUpper();
// Module definition
- Double_t par[10], parTubs[5], xpos=0., ypos=0., zpos=0., rpos=0.;
+ Double_t par[10], xpos=0., ypos=0., zpos=0.;
Double_t parSCPA[5], zposSCPA=0.; // passive SC - 13-MAY-05, TRD1 case
Double_t trd1Angle = g->GetTrd1Angle()*TMath::DegToRad(), tanTrd1 = TMath::Tan(trd1Angle/2.);
- Double_t tanTrd2y = TMath::Tan(g->GetTrd2AngleY()*TMath::DegToRad()/2.);
int nr=0;
fIdRotm=0;
if(!gn.Contains("TRD")) { // standard module
gMC->Gspos ("SCPA", ++nr, child, 0.0, 0.0, zposSCPA, 0, "ONLY");
}
}
- } else if (gn.Contains("TRD2")){ // TRD2 as for TRD1 - 27-jan-05
- fParEMOD[0] = g->GetEtaModuleSize()/2.; // dx1
- fParEMOD[1] = g->Get2Trd1Dx2()/2.; // dx2
- fParEMOD[2] = g->GetPhiModuleSize()/2.; // dy1
- fParEMOD[3] = fParEMOD[2] + tanTrd2y*g->GetLongModuleSize();// dy2
- fParEMOD[4] = g->GetLongModuleSize()/2.; // dz
- gMC->Gsvolu(child, "TRD2", fIdTmedArr[kIdSTEEL], fParEMOD, 5);
}
nr = 0;
// printf(" %3i(%2i,2i) xpos %7.2f ypos %7.2f zpos %7.2f \n", nr,iy,iz, xpos, ypos, zpos);
}
}
- } else if(gn.Contains("TRD")) { // 30-sep-04; 27-jan-05 - as for TRD1 as for TRD2
+ } else if(gn.Contains("TRD")) { // 30-sep-04; 27-jan-05 - as for TRD1
// X->Z(0, 0); Y->Y(90, 90); Z->X(90, 0)
- AliEMCALShishKebabTrd1Module *mod=0, *mTmp; // current module
+ AliEMCALShishKebabTrd1Module *mod=0; // current module
for(int iz=0; iz<g->GetNZ(); iz++) {
Double_t angle=90., phiOK=0;
}
printf("\n");
}
- } else if(gn.Contains("TRD2")){ // 1-feb-05 - TRD2; curve in phi
- double angEtaRow = 0.;
- double theta1=0.,phi1=0., theta2=0.,phi2=0., theta3=0.,phi3=0.;
- angle=90.;
- if(iz==0) {
- mod = new AliEMCALShishKebabTrd1Module();
- } else {
- mTmp = new AliEMCALShishKebabTrd1Module(*mod);
- mod = mTmp;
- angle = mod->GetThetaInDegree();
- }
-
- fShishKebabModules->Add(mod);
- phiOK = mod->GetCenterOfModule().Phi()*180./TMath::Pi();
- AliDebug(2,Form(" %i | theta | %6.3f - %6.3f = %6.3f\n", iz+1, angle, phiOK, angle-phiOK));
-
- zpos = mod->GetPosZ() - parTubs[2];
- rpos = parTubs[0] + mod->GetPosXfromR();
-
- angle = mod->GetThetaInDegree();
- Double_t stepAngle = (parTubs[4] - parTubs[3])/g->GetNPhi(); // 11-mar-04
- for(int iy=0; iy<g->GetNPhi(); iy++) {
- angEtaRow = parTubs[3] + stepAngle*(0.5+double(iy));
- // angEtaRow = 0;
- theta1 = 90. + angle; phi1 = angEtaRow; // x' ~-z;
- theta2 = 90.; phi2 = 90. + angEtaRow;// y' ~ y;
- theta3 = angle; phi3 = angEtaRow; // z' ~ x;
- if(phi3 < 0.0) phi3 += 360.;
- AliMatrix(fIdRotm, theta1,phi1, theta2,phi2, theta3,phi3);
-
- xpos = rpos * TMath::Cos(angEtaRow*TMath::DegToRad());
- ypos = rpos * TMath::Sin(angEtaRow*TMath::DegToRad());
- gMC->Gspos(child, ++nr, "SMOP", xpos, ypos, zpos, fIdRotm, "ONLY") ;
- // SMON;
- phi1 = 180 + angEtaRow;
- theta3 = 180.-theta3; phi3 = angEtaRow;
- AliMatrix(fIdRotm, theta1,phi1, theta2,phi2, theta3,phi3);
- gMC->Gspos(child, nr, "SMON", xpos, ypos, -zpos, fIdRotm, "ONLY") ;
- if(AliDebugLevel()>=2) {
- printf(" angEtaRow(phi) %7.2f | angle(eta) %7.2f \n", angEtaRow, angle);
- printf("iy=%2i xpos %7.2f ypos %7.2f zpos %7.2f fIdRotm %i\n", iy, xpos, ypos, zpos, fIdRotm);
- }
- } // for(int iy=0; iy<g->GetNPhi(); iy++)
}
}
} else {
fTree = 0;
}
-void AliEMCALJetMicroDst::Browse(TBrowser* b) const
+void AliEMCALJetMicroDst::Browse(TBrowser* b)
{
// Browse
if(fTree) b->Add((TObject*)fTree);
Bool_t IsPythiaDst() const ;
virtual Bool_t IsFolder() const;
- virtual void Browse(TBrowser* b) const;
+ virtual void Browse(TBrowser* b);
// service routine
static TList *MoveHistsToList(const char* name="ListOfHists", Bool_t putToBrowser=kTRUE);
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff