inline void ConnectParFileToRuntimeDb(const TString par_file, FairRuntimeDb* rtdb) { FairParRootFileIo* io = new FairParRootFileIo(); io->open(par_file); rtdb->setFirstInput(io); rtdb->setOutput(io); rtdb->saveOutput(); }
void AnalysisTaskXi(TString pre = "", int nevts=0, double mom=2.7){ TDatabasePDG::Instance()-> AddParticle("pbarpSystem","pbarpSystem", 1.9, kFALSE, 0.1, 0,"", 88888); //Output File if (pre==""){ TString Path = "/private/puetz/mysimulations/analysis/pbarp_Xiplus_Ximinus/idealtracking/10000_events/"; TString outPath = Path; TString OutputFile = outPath + "analysis_output_test.root"; //Input simulation Files TString inPIDFile = Path + "pid_complete.root"; TString inParFile = Path + "simparams.root"; } else{ TString Path = pre; TString outPath = Path + "_test_"; TString OutputFile = Path + "_analysis_output.root"; //Input simulation Files TString inPIDFile = Path + "_pid_complete.root"; TString inParFile = Path + "_simparams.root"; } TString PIDParFile = TString( gSystem->Getenv("VMCWORKDIR")) + "/macro/params/all.par"; //Initialization FairLogger::GetLogger()->SetLogToFile(kFALSE); FairRunAna* RunAna = new FairRunAna(); FairRuntimeDb* rtdb = RunAna->GetRuntimeDb(); RunAna->SetInputFile(inPIDFile); //setup parameter database FairParRootFileIo* parIo = new FairParRootFileIo(); parIo->open(inParFile); FairParAsciiFileIo* parIoPID = new FairParAsciiFileIo(); parIoPID->open(PIDParFile.Data(),"in"); rtdb->setFirstInput(parIo); rtdb->setSecondInput(parIoPID); rtdb->setOutput(parIo); RunAna->SetOutputFile(OutputFile); // *** HERE OUR TASK GOES! AnalysisTask *anaTask = new AnalysisTask(); anaTask->SetOutPutDir(outPath); anaTask->SetNEvents(nevts); anaTask->SetMom(mom); RunAna->AddTask(anaTask); RunAna->Init(); RunAna->Run(0.,1.); exit(0);
void ana(int iplab = 0, int itype = 0, int brem = 1, int fid=0, int nevts = 10000) { gSystem->Load("libanatda"); gSystem->ListLibraries(); //double plab[3] = {5.513, 8., 12.}; //const char *tt[2] = {"pip_pim","jpsi"}; //const char *cbrem[2] = {"raw","brem"}; //TString inPidFile = Form("output/pid/pbar_p_%s_pi0_plab%3.1f_%d.root", tt[itype], plab[iplab], fid); //TString inParFile = Form("output/par/pbar_p_%s_pi0_plab%3.1f_%d.root", tt[itype], plab[iplab], fid); //TString outFile = Form("test/ana_%s_%s_plab%3.1f_%d.root", tt[itype], cbrem[brem], plab[iplab], fid); //cout << "inPidFile= " << inPidFile << endl; //cout << "inParFile= " << inParFile << endl; //cout << " tt= " << tt[itype] << " Outfile= " << outFile << endl; const char *tt[2] = {"pi0pipm_dpm","pi0jpsi"}; const char *cbrem[2] = {"raw","brem"}; const char *dir = Form("/vol0/panda/work/jpsi_pi0/grid.out/tda/%s/runall.%d.%d", tt[itype], iplab, fid); TString inPidFile = Form("%s/pid_complete.root",dir); TString inParFile = Form("%s/simparams.root",dir); TString outFile = Form("%s/ana_%s.root",dir,cbrem[brem]); cout << "inPidFile= " << inPidFile << endl; cout << "inParFile= " << inParFile << endl; cout << "outFile= " << outFile << endl; // *** initialization FairLogger::GetLogger()->SetLogToFile(kFALSE); FairRunAna* fRun = new FairRunAna(); fRun->SetInputFile(inPidFile); FairRuntimeDb* rtdb = fRun->GetRuntimeDb(); FairParRootFileIo* parIO = new FairParRootFileIo(); parIO->open(inParFile); FairParAsciiFileIo* parIOPid = new FairParAsciiFileIo(); parIOPid->open((TString(gSystem->Getenv("VMCWORKDIR"))+"/macro/params/all.par").Data(),"in"); rtdb->setFirstInput(parIO); rtdb->setSecondInput(parIOPid); rtdb->setOutput(parIO); AnaTda *atda = new AnaTda(iplab, itype, brem); atda->set_verbosity(0); fRun->AddTask(atda); fRun->SetOutputFile(outFile); fRun->Init(); fRun->Run(0,nevts); cout << "Done with: " << outFile << endl; }
Int_t califa_test() { // Create a Runtime Database singleton. FairRuntimeDb* db = FairRuntimeDb::instance(); // Create in memory the relevant container R3BCaloCalPar* par = (R3BCaloCalPar*)(db->getContainer("CaloCalPar")); // Set the SQL IO as first input FairParAsciiFileIo* inp = new FairParAsciiFileIo(); TString filename ="ducals.par"; inp->open(filename.Data(),"in"); db->setFirstInput(inp); // Generate a unique RunID FairRunIdGenerator runID; UInt_t runId = runID.generateId(); db->initContainers(runId); // Get the container after initialisation // from the RuntimeDB R3BCaloCalPar* par = (R3BCaloCalPar*)(db->getContainer("CaloCalPar")); // Dump the Parameters cout << endl; cout << "-I- Reading Parameter data from Ascii File: \n" << filename.Data() << endl; cout << endl; par->Print(); cout << endl; // Convert in ROOT format par->setChanged(); Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open("califa_cal_par.root"); db->setOutput(parOut); db->saveOutput(); db->print(); // ------------------------------------------------------------------------ if (db) delete db; return 0; }
r3bevtvis() { // ----- Reconstruction run ------------------------------------------- FairRunAna *fRun= new FairRunAna(); TFile* file = new TFile("r3bpar.root"); file->Get("FairBaseParSet"); // ----- Runtime database --------------------------------------------- FairRuntimeDb* rtdb = fRun->GetRuntimeDb(); FairParRootFileIo* parIn = new FairParRootFileIo(); parIn->open("r3bpar.root"); rtdb->print(); fRun->SetInputFile("r3bsim.root"); fRun->SetOutputFile("test.root"); //fRun->LoadGeometry(); R3BEventManager *fMan= new R3BEventManager(); R3BMCTracks *Track = new R3BMCTracks ("Monte-Carlo Tracks"); fMan->AddTask(Track); fMan->Init(); }
void run_sample_data() { TStopwatch timer; timer.Start(); const Int_t nev = -1; // number of events to read, -1 - untill CTRL+C const Int_t trigger = -1; // 1 - onspill, 2 - offspill. -1 - all TString filename = "sample_data_2.lmd"; TString outputFileName = "output_raw_land.root"; // name of output file const Int_t refresh = 100000; // refresh rate for saving control histograms TString parFileName = "params_raw_land.root"; // name of parameter file const Int_t updateRate = 150000; const Int_t minStats = 10000; // minimum number of entries for TCAL calibration const Int_t nModules = 800; // number of photomultipliers (for TCAL calibration) // Create source with unpackers ---------------------------------------------- TString ntuple_options = "UNPACK:EVENTNO,UNPACK:TRIGGER,RAW"; TString ucesb_dir = getenv("UCESB_DIR"); TString ucesb_path = ucesb_dir + "/../upexps/s438b/s438b"; EXT_STR_h101 ucesb_struct; R3BUcesbSource* source = new R3BUcesbSource(filename, ntuple_options, ucesb_path, &ucesb_struct, sizeof(ucesb_struct)); source->SetMaxEvents(nev); source->AddReader(new R3BUnpackReader((EXT_STR_h101_unpack*)&ucesb_struct.unpack, offsetof(EXT_STR_h101, unpack))); source->AddReader(new R3BNeulandTacquilaReader((EXT_STR_h101_raw_nnp*)&ucesb_struct.nnp, offsetof(EXT_STR_h101, nnp))); source->AddReader(new R3BLosReader((EXT_STR_h101_LOS*)&ucesb_struct.los, offsetof(EXT_STR_h101, los))); // --------------------------------------------------------------------------- // Create online run --------------------------------------------------------- FairRunOnline* run = new FairRunOnline(source); run->SetOutputFile(outputFileName.Data()); run->SetRunId(1111); // --------------------------------------------------------------------------- // Create ALADIN field map --------------------------------------------------- R3BAladinFieldMap* magField = new R3BAladinFieldMap("AladinMaps"); Double_t fMeasCurrent = 2500.; // I_current [A] magField->SetCurrent(fMeasCurrent); magField->SetScale(1.); run->SetField(magField); // --------------------------------------------------------------------------- // TCAL ---------------------------------------------------------------------- R3BNeulandMapped2CalPar* tcalFill = new R3BNeulandMapped2CalPar("TcalFill"); tcalFill->SetUpdateRate(updateRate); tcalFill->SetMinStats(minStats); tcalFill->SetTrigger(trigger); tcalFill->SetNofModules(nModules); run->AddTask(tcalFill); R3BLosMapped2CalPar* losTcalFill = new R3BLosMapped2CalPar("LosTcalFill"); losTcalFill->SetUpdateRate(updateRate); losTcalFill->SetMinStats(minStats); losTcalFill->SetNofModules(1, 4); run->AddTask(losTcalFill); // --------------------------------------------------------------------------- // Add analysis task --------------------------------------------------------- R3BNeulandMappedHist* ana = new R3BNeulandMappedHist("LandRawAna", 1); run->AddTask(ana); // --------------------------------------------------------------------------- // Initialize ---------------------------------------------------------------- run->Init(); FairLogger::GetLogger()->SetLogScreenLevel("INFO"); // --------------------------------------------------------------------------- // Runtime data base --------------------------------------------------------- FairRuntimeDb* rtdb = run->GetRuntimeDb(); R3BFieldPar* fieldPar = (R3BFieldPar*)rtdb->getContainer("R3BFieldPar"); fieldPar->SetParameters(magField); fieldPar->setChanged(); Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFileName); rtdb->setOutput(parOut); rtdb->print(); // --------------------------------------------------------------------------- // Run ----------------------------------------------------------------------- if(nev < 0) { run->Run(nev, 0); } else { run->Run(0, nev); } rtdb->saveOutput(); // --------------------------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << outputFileName << endl; cout << "Parameter file is " << parFileName << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; if(ana->GetNItemsTotal() > 3800) { cout << " Test passed" << endl; cout << " All ok " << endl; } delete run; }
void global_sim(Int_t nEvents = 10, Int_t seed = 555) { gRandom->SetSeed(seed); TString script = TString(gSystem->Getenv("LIT_SCRIPT")); // Files // TString urqmdFile = "/Users/andrey/Development/cbm/d/urqmd/auau/25gev/centr/urqmd.auau.25gev.centr.0000.ftn14"; // input UrQMD file TString urqmdFile = "../../input/urqmd.auau.25gev.centr.0000.ftn14"; // input UrQMD file TString dir = "data/"; // Directory for output simulation files TString mcFile = dir + "mc.0000.root"; //MC file name TString parFile = dir + "param.0000.root"; //Parameter file name // Geometry TString caveGeom = "cave.geo"; TString targetGeom = "target_au_250mu.geo"; TString pipeGeom = "pipe_standard.geo"; TString stsGeom = "sts/sts_v12b.geo.root"; TString richGeom = "rich/rich_v08a.geo"; TString tofGeom = "tof/tof_V13b.geo"; TString fieldMap = "field_v12a"; TString magnetGeom = "passive/magnet_v12a.geo"; // If SCRIPT environment variable is set to "yes", i.e. macro is run via script if (script == "yes") { urqmdFile = TString(gSystem->Getenv("LIT_URQMD_FILE")); mcFile = TString(gSystem->Getenv("LIT_MC_FILE")); parFile = TString(gSystem->Getenv("LIT_PAR_FILE")); } // ----- Magnetic field ----------------------------------------------- Double_t fieldZ = 50.; // field center z position Double_t fieldScale = 1.; // field scaling factor TStopwatch timer; timer.Start(); gROOT->LoadMacro("$VMCWORKDIR/macro/littrack/loadlibs.C"); loadlibs(); FairRunSim* fRun = new FairRunSim(); fRun->SetName("TGeant3"); // Transport engine fRun->SetOutputFile(mcFile); // Output file FairRuntimeDb* rtdb = fRun->GetRuntimeDb(); fRun->SetMaterials("media.geo"); // Materials // fRun->SetStoreTraj(kTRUE); if ( caveGeom != "" ) { FairModule* cave = new CbmCave("CAVE"); cave->SetGeometryFileName(caveGeom); fRun->AddModule(cave); cout << " --- " << caveGeom << endl; } if ( pipeGeom != "" ) { FairModule* pipe = new CbmPipe("PIPE"); pipe->SetGeometryFileName(pipeGeom); fRun->AddModule(pipe); cout << " --- " << pipeGeom << endl; } if ( targetGeom != "" ) { FairModule* target = new CbmTarget("Target"); target->SetGeometryFileName(targetGeom); fRun->AddModule(target); cout << " --- " << targetGeom << endl; } if ( magnetGeom != "" ) { FairModule* magnet = new CbmMagnet("MAGNET"); magnet->SetGeometryFileName(magnetGeom); fRun->AddModule(magnet); cout << " --- " << magnetGeom << endl; } if ( stsGeom != "" ) { FairDetector* sts = new CbmSts("STS", kTRUE); sts->SetGeometryFileName(stsGeom); fRun->AddModule(sts); cout << " --- " << stsGeom << endl; } if ( richGeom != "" ) { FairDetector* rich = new CbmRich("RICH", kTRUE); rich->SetGeometryFileName(richGeom); fRun->AddModule(rich); } if ( tofGeom != "" ) { FairDetector* tof = new CbmTof("TOF", kTRUE); tof->SetGeometryFileName(tofGeom); fRun->AddModule(tof); cout << " --- " << tofGeom << endl; } // ------------------------------------------------------------------------ // ----- Create magnetic field ---------------------------------------- CbmFieldMap* magField = new CbmFieldMapSym2(fieldMap); magField->SetPosition(0., 0., fieldZ); magField->SetScale(fieldScale); fRun->SetField(magField); // ------------------------------------------------------------------------ CbmMCEventHeader* mcHeader = new CbmMCEventHeader(); fRun->SetMCEventHeader(mcHeader); // ------------------------------------------------------------------------ FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); // CbmUnigenGenerator* urqmdGen = new CbmUnigenGenerator(urqmdFile); CbmUrqmdGenerator* urqmdGen = new CbmUrqmdGenerator(urqmdFile); primGen->AddGenerator(urqmdGen); fRun->SetGenerator(primGen); fRun->Init(); // ----- Runtime database --------------------------------------------- CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar"); fieldPar->SetParameters(magField); fieldPar->setChanged(); fieldPar->setInputVersion(fRun->GetRunId(),1); Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ------------------------------------------------------------------------ // ----- Start run ---------------------------------------------------- fRun->Run(nEvents); // ------------------------------------------------------------------------ // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished successfully." << endl; cout << "Test passed"<< endl; cout << " All ok " << endl; cout << "Output file is " << mcFile << endl; cout << "Real time used: " << rtime << "s " << endl; cout << "CPU time used : " << ctime << "s " << endl << endl << endl; // ------------------------------------------------------------------------ }
void r3ball(Int_t nEvents = 1, TMap* fDetList = NULL, TString Target = "LeadTarget", Bool_t fVis = kFALSE, TString fMC = "TGeant3", TString fGenerator = "box", Bool_t fUserPList = kFALSE, Bool_t fR3BMagnet = kTRUE, Double_t fMeasCurrent = 2000., TString OutFile = "r3bsim.root", TString ParFile = "r3bpar.root", TString InFile = "evt_gen.dat") { TString dir = getenv("VMCWORKDIR"); TString r3bdir = dir + "/macros"; TString r3b_geomdir = dir + "/geometry"; gSystem->Setenv("GEOMPATH",r3b_geomdir.Data()); TString r3b_confdir = dir + "gconfig"; gSystem->Setenv("CONFIG_DIR",r3b_confdir.Data()); // In general, the following parts need not be touched // ======================================================================== // ---- Debug option ------------------------------------------------- gDebug = 0; // ------------------------------------------------------------------------ // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ------------------------------------------------------------------------ // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName(fMC.Data()); // Transport engine run->SetOutputFile(OutFile.Data()); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // R3B Special Physics List in G4 case if ( (fUserPList == kTRUE ) && (fMC.CompareTo("TGeant4") == 0)) { run->SetUserConfig("g4R3bConfig.C"); run->SetUserCuts("SetR3BCuts.C"); } // ----- Create media ------------------------------------------------- run->SetMaterials("media_r3b.geo"); // Materials // Magnetic field map type Int_t fFieldMap = 0; // Global Transformations //- Two ways for a Volume Rotation are supported //-- 1) Global Rotation (Euler Angles definition) //-- This represent the composition of : first a rotation about Z axis with //-- angle phi, then a rotation with theta about the rotated X axis, and //-- finally a rotation with psi about the new Z axis. Double_t phi,theta,psi; //-- 2) Rotation in Ref. Frame of the Volume //-- Rotation is Using Local Ref. Frame axis angles Double_t thetaX,thetaY,thetaZ; //- Global Translation Lab. frame. Double_t tx,ty,tz; // ----- Create R3B geometry -------------------------------------------- //R3B Cave definition FairModule* cave= new R3BCave("CAVE"); cave->SetGeometryFileName("r3b_cave.geo"); run->AddModule(cave); //R3B Target definition if (fDetList->FindObject("TARGET") ) { R3BModule* target= new R3BTarget(Target.Data()); target->SetGeometryFileName(((TObjString*)fDetList->GetValue("TARGET"))->GetString().Data()); run->AddModule(target); } //R3B SiTracker Cooling definition if (fDetList->FindObject("VACVESSELCOOL") ) { R3BModule* vesselcool= new R3BVacVesselCool(Target.Data()); vesselcool->SetGeometryFileName(((TObjString*)fDetList->GetValue("VACVESSELCOOL"))->GetString().Data()); run->AddModule(vesselcool); } //R3B Magnet definition if (fDetList->FindObject("ALADIN") ) { fFieldMap = 0; R3BModule* mag = new R3BMagnet("AladinMagnet"); mag->SetGeometryFileName(((TObjString*)fDetList->GetValue("ALADIN"))->GetString().Data()); run->AddModule(mag); } //R3B Magnet definition if (fDetList->FindObject("GLAD") ) { fFieldMap = 1; R3BModule* mag = new R3BGladMagnet("GladMagnet"); mag->SetGeometryFileName(((TObjString*)fDetList->GetValue("GLAD"))->GetString().Data()); run->AddModule(mag); } if (fDetList->FindObject("CRYSTALBALL") ) { //R3B Crystal Calorimeter R3BDetector* xball = new R3BXBall("XBall", kTRUE); xball->SetGeometryFileName(((TObjString*)fDetList->GetValue("CRYSTALBALL"))->GetString().Data()); run->AddModule(xball); } if (fDetList->FindObject("CALIFA") ) { // CALIFA Calorimeter R3BDetector* calo = new R3BCalo("Califa", kTRUE); ((R3BCalo *)calo)->SelectGeometryVersion(10); //Selecting the Non-uniformity of the crystals (1 means +-1% max deviation) ((R3BCalo *)calo)->SetNonUniformity(1.0); calo->SetGeometryFileName(((TObjString*)fDetList->GetValue("CALIFA"))->GetString().Data()); run->AddModule(calo); } // Tracker if (fDetList->FindObject("TRACKER") ) { R3BDetector* tra = new R3BTra("Tracker", kTRUE); tra->SetGeometryFileName(((TObjString*)fDetList->GetValue("TRACKER"))->GetString().Data()); tra->SetEnergyCut(1e-4); run->AddModule(tra); } // STaRTrack if (fDetList->FindObject("STaRTrack") ) { R3BDetector* tra = new R3BSTaRTra("STaRTrack", kTRUE); tra->SetGeometryFileName(((TObjString*)fDetList->GetValue("STaRTrack"))->GetString().Data()); run->AddModule(tra); } // DCH drift chambers if (fDetList->FindObject("DCH") ) { R3BDetector* dch = new R3BDch("Dch", kTRUE); dch->SetGeometryFileName(((TObjString*)fDetList->GetValue("DCH"))->GetString().Data()); run->AddModule(dch); } // Tof if (fDetList->FindObject("TOF") ) { R3BDetector* tof = new R3BTof("Tof", kTRUE); tof->SetGeometryFileName(((TObjString*)fDetList->GetValue("TOF"))->GetString().Data()); run->AddModule(tof); } // mTof if (fDetList->FindObject("MTOF") ) { R3BDetector* mTof = new R3BmTof("mTof", kTRUE); mTof->SetGeometryFileName(((TObjString*)fDetList->GetValue("MTOF"))->GetString().Data()); run->AddModule(mTof); } // dTof if (fDetList->FindObject("DTOF") ) { R3BDetector* dTof = new R3BdTof("dTof", kTRUE); dTof->SetGeometryFileName(((TObjString*)fDetList->GetValue("DTOF"))->GetString().Data()); run->AddModule(dTof); } // GFI detector if (fDetList->FindObject("GFI") ) { R3BDetector* gfi = new R3BGfi("Gfi", kTRUE); gfi->SetGeometryFileName(((TObjString*)fDetList->GetValue("GFI"))->GetString().Data()); run->AddModule(gfi); } // Land Detector if (fDetList->FindObject("LAND") ) { R3BDetector* land = new R3BLand("Land", kTRUE); land->SetVerboseLevel(1); land->SetGeometryFileName(((TObjString*)fDetList->GetValue("LAND"))->GetString().Data()); run->AddModule(land); } // NeuLand Scintillator Detector if(fDetList->FindObject("SCINTNEULAND")) { R3BDetector* land = new R3BLand("Land", kTRUE); land->SetVerboseLevel(1); land->SetGeometryFileName(((TObjString*)fDetList->GetValue("SCINTNEULAND"))->GetString().Data()); run->AddModule(land); } // MFI Detector if(fDetList->FindObject("MFI")) { R3BDetector* mfi = new R3BMfi("Mfi", kTRUE); mfi->SetGeometryFileName(((TObjString*)fDetList->GetValue("MFI"))->GetString().Data()); run->AddModule(mfi); } // PSP Detector if(fDetList->FindObject("PSP")) { R3BDetector* psp = new R3BPsp("Psp", kTRUE); psp->SetGeometryFileName(((TObjString*)fDetList->GetValue("PSP"))->GetString().Data()); run->AddModule(psp); } // Luminosity detector if (fDetList->FindObject("LUMON") ) { R3BDetector* lumon = new ELILuMon("LuMon", kTRUE); lumon->SetGeometryFileName(((TObjString*)fDetList->GetValue("LUMON"))->GetString().Data()); run->AddModule(lumon); } // ----- Create R3B magnetic field ---------------------------------------- Int_t typeOfMagneticField = 0; Int_t fieldScale = 1; Bool_t fVerbose = kFALSE; //NB: <D.B> // If the Global Position of the Magnet is changed // the Field Map has to be transformed accordingly FairField *magField = NULL; if (fFieldMap == 0) { magField = new R3BAladinFieldMap("AladinMaps"); ((R3BAladinFieldMap*)magField)->SetCurrent(fMeasCurrent); ((R3BAladinFieldMap*)magField)->SetScale(fieldScale); if ( fR3BMagnet == kTRUE ) { run->SetField(magField); } else { run->SetField(NULL); } } else if(fFieldMap == 1){ magField = new R3BGladFieldMap("R3BGladMap"); ((R3BGladFieldMap*)magField)->SetPosition(0., 0., +350-119.94); ((R3BGladFieldMap*)magField)->SetScale(fieldScale); if ( fR3BMagnet == kTRUE ) { run->SetField(magField); } else { run->SetField(NULL); } } //! end of field map section // ----- Create PrimaryGenerator -------------------------------------- // 1 - Create the Main API class for the Generator FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); if (fGenerator.CompareTo("box") == 0 ) { // 2- Define the BOX generator Int_t pdgId = 211; // pion beam Double32_t theta1 = 0.; // polar angle distribution Double32_t theta2 = 7.; Double32_t momentum = 0.8; FairBoxGenerator* boxGen = new FairBoxGenerator(pdgId, 50); boxGen->SetThetaRange(theta1, theta2); boxGen->SetPRange(momentum, momentum*2.); boxGen->SetPhiRange(0, 360); boxGen->SetXYZ(0.0, 0.0, -1.5); // boxGen->SetXYZ(0.0, 0.0, -300.); // add the box generator primGen->AddGenerator(boxGen); } if (fGenerator.CompareTo("ascii") == 0 ) { R3BAsciiGenerator* gen = new R3BAsciiGenerator((dir+"/input/"+InFile).Data()); primGen->AddGenerator(gen); } if (fGenerator.CompareTo("r3b") == 0 ) { R3BSpecificGenerator *pR3bGen = new R3BSpecificGenerator(); // R3bGen properties pR3bGen->SetBeamInteractionFlag("off"); pR3bGen->SetBeamInteractionFlag("off"); pR3bGen->SetRndmFlag("off"); pR3bGen->SetRndmEneFlag("off"); pR3bGen->SetBoostFlag("off"); pR3bGen->SetReactionFlag("on"); pR3bGen->SetGammasFlag("off"); pR3bGen->SetDecaySchemeFlag("off"); pR3bGen->SetDissociationFlag("off"); pR3bGen->SetBackTrackingFlag("off"); pR3bGen->SetSimEmittanceFlag("off"); // R3bGen Parameters pR3bGen->SetBeamEnergy(1.); // Beam Energy in GeV pR3bGen->SetSigmaBeamEnergy(1.e-03); // Sigma(Ebeam) GeV pR3bGen->SetParticleDefinition(2212); // Use Particle Pdg Code pR3bGen->SetEnergyPrim(0.3); // Particle Energy in MeV Int_t fMultiplicity = 50; pR3bGen->SetNumberOfParticles(fMultiplicity); // Mult. // Reaction type // 1: "Elas" // 2: "iso" // 3: "Trans" pR3bGen->SetReactionType("Elas"); // Target type // 1: "LeadTarget" // 2: "Parafin0Deg" // 3: "Parafin45Deg" // 4: "LiH" pR3bGen->SetTargetType(Target.Data()); Double_t thickness = (0.11/2.)/10.; // cm pR3bGen->SetTargetHalfThicknessPara(thickness); // cm pR3bGen->SetTargetThicknessLiH(3.5); // cm pR3bGen->SetTargetRadius(1.); // cm pR3bGen->SetSigmaXInEmittance(1.); //cm pR3bGen->SetSigmaXPrimeInEmittance(0.0001); //cm // Dump the User settings pR3bGen->PrintParameters(); primGen->AddGenerator(pR3bGen); } run->SetGenerator(primGen); //-------Set visualisation flag to true------------------------------------ run->SetStoreTraj(fVis); FairLogger::GetLogger()->SetLogVerbosityLevel("LOW"); // ----- Initialize simulation run ------------------------------------ run->Init(); // ------ Increase nb of step for CALO Int_t nSteps = -15000; gMC->SetMaxNStep(nSteps); // ----- Runtime database --------------------------------------------- R3BFieldPar* fieldPar = (R3BFieldPar*) rtdb->getContainer("R3BFieldPar"); if(NULL != magField) { fieldPar->SetParameters(magField); fieldPar->setChanged(); } Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(ParFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ----- Start run ---------------------------------------------------- if(nEvents > 0) { run->Run(nEvents); } // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << OutFile << endl; cout << "Parameter file is " << ParFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; // ------------------------------------------------------------------------ cout << " Test passed" << endl; cout << " All ok " << endl; }
void run_tutorial4(Int_t nEvents = 10) { TString dir = getenv("VMCWORKDIR"); TString tutdir = dir + "/Tutorial4"; TString tut_geomdir = dir + "/geometry"; gSystem->Setenv("GEOMPATH",tut_geomdir.Data()); TString tut_configdir = dir + "/Tutorial4/macros/gconfig"; gSystem->Setenv("CONFIG_DIR",tut_configdir.Data()); Double_t momentum = 2.; Double_t theta = 2.; TString outDir = "./"; // Output file name TString outFile ="data/testrun.root"; TString parFile ="data/testparams.root"; TList *parFileList = new TList(); TString workDir = gSystem->Getenv("VMCWORKDIR"); paramDir = workDir + "/Tutorial4/macros/parameters/"; TObjString tutDetDigiFile = paramDir + "example.par"; parFileList->Add(&tutDetDigiFile); // In general, the following parts need not be touched // ======================================================================== // ---- Debug option ------------------------------------------------- gDebug = 0; // ------------------------------------------------------------------------ // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ------------------------------------------------------------------------ //Does not work with automatic loading pf libraries. The info is not in the rootmap file // gLogger->SetLogScreenLevel("INFO"); // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName("TGeant3"); // Transport engine run->SetOutputFile(outFile); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // ------------------------------------------------------------------------ // ----- Create media ------------------------------------------------- run->SetMaterials("media.geo"); // Materials // ------------------------------------------------------------------------ // ----- Create geometry ---------------------------------------------- FairModule* cave= new FairCave("CAVE"); cave->SetGeometryFileName("cave_vacuum.geo"); run->AddModule(cave); FairTutorialDet4* tutdet = new FairTutorialDet4("TUTDET", kTRUE); tutdet->SetGeometryFileName("tutorial4.root"); tutdet->SetModifyGeometry(kTRUE); run->AddModule(tutdet); // ------------------------------------------------------------------------ // ----- Create PrimaryGenerator -------------------------------------- FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); FairBoxGenerator* boxGen = new FairBoxGenerator(2212, 1); boxGen->SetThetaRange ( theta, theta+0.1); // boxGen->SetThetaRange ( 0., 0.); boxGen->SetPRange (momentum,momentum+0.01); boxGen->SetPhiRange (0.,360.); boxGen->SetBoxXYZ (-20.,-20.,20.,20., 0.); // boxGen->SetBoxXYZ (0.,0.,0.,0., 0.); // boxGen->SetDebug(kTRUE); primGen->AddGenerator(boxGen); run->SetGenerator(primGen); // ------------------------------------------------------------------------ // ----- Initialize simulation run ------------------------------------ run->SetStoreTraj(kTRUE); // ----- Runtime database --------------------------------------------- Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); FairParAsciiFileIo* parIn = new FairParAsciiFileIo(); parOut->open(parFile.Data()); parIn->open(parFileList, "in"); rtdb->setFirstInput(parIn); rtdb->setOutput(parOut); // ------------------------------------------------------------------------ run->Init(); // -Trajectories Visualization (TGeoManager Only ) // ----------------------------------------------- // Set cuts for storing the trajectpries /* FairTrajFilter* trajFilter = FairTrajFilter::Instance(); trajFilter->SetStepSizeCut(0.01); // 1 cm trajFilter->SetVertexCut(-2000., -2000., 4., 2000., 2000., 100.); trajFilter->SetMomentumCutP(10e-3); // p_lab > 10 MeV trajFilter->SetEnergyCut(0., 1.02); // 0 < Etot < 1.04 GeV trajFilter->SetStorePrimaries(kTRUE); trajFilter->SetStoreSecondaries(kTRUE); */ // ------------------------------------------------------------------------ // ----- Start run ---------------------------------------------------- run->Run(nEvents); run->CreateGeometryFile("data/geofile_full.root"); // ------------------------------------------------------------------------ rtdb->saveOutput(); rtdb->print(); delete run; // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << outFile << endl; cout << "Parameter file is " << parFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; // ------------------------------------------------------------------------ cout << " Test passed" << endl; cout << " All ok " << endl; }
void he6_sim(Int_t nEvents = 10000, TString mcEngine = "TGeant4") { TString dir = getenv("VMCWORKDIR"); // Output file name TString outFile ="./data/attpcsim.root"; // Parameter file name TString parFile="./data/attpcpar.root"; // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ------------------------------------------------------------------------ //gSystem->Load("libAtGen.so"); ATVertexPropagator* vertex_prop = new ATVertexPropagator(); // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName(mcEngine); // Transport engine run->SetOutputFile(outFile); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // ------------------------------------------------------------------------ // ----- Create media ------------------------------------------------- run->SetMaterials("media.geo"); // Materials // ------------------------------------------------------------------------ // ----- Create geometry ---------------------------------------------- FairModule* cave= new AtCave("CAVE"); cave->SetGeometryFileName("cave.geo"); run->AddModule(cave); FairModule* magnet = new AtMagnet("Magnet"); run->AddModule(magnet); /*FairModule* pipe = new AtPipe("Pipe"); run->AddModule(pipe);*/ FairDetector* ATTPC = new AtTpc("ATTPC", kTRUE); ATTPC->SetGeometryFileName("ATTPC_Proto_v1.0.root"); //ATTPC->SetModifyGeometry(kTRUE); run->AddModule(ATTPC); // ------------------------------------------------------------------------ // ----- Magnetic field ------------------------------------------- // Constant Field AtConstField *fMagField = new AtConstField(); fMagField->SetField(0., 0. ,0. ); // values are in kG fMagField->SetFieldRegion(-50, 50,-50, 50, -10,230); // values are in cm // (xmin,xmax,ymin,ymax,zmin,zmax) run->SetField(fMagField); // -------------------------------------------------------------------- // ----- Create PrimaryGenerator -------------------------------------- FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); // Beam Information Int_t z = 2; // Atomic number Int_t a = 8; // Mass number Int_t q = 0; // Charge State Int_t m = 1; // Multiplicity NOTE: Due the limitation of the TGenPhaseSpace accepting only pointers/arrays the maximum multiplicity has been set to 10 particles. Double_t px = 0.000/a; // X-Momentum / per nucleon!!!!!! Double_t py = 0.000/a; // Y-Momentum / per nucleon!!!!!! Double_t pz = 0.504708/a; // Z-Momentum / per nucleon!!!!!! Double_t BExcEner = 0.0; Double_t Bmass = 7.483551; //Mass in GeV Double_t NomEnergy = 17.0; //Nominal Energy of the beam: Only used for cross section calculation (Tracking energy is determined with momentum). TODO: Change this to the energy after the IC Double_t TargetMass = 3.728401;//Mass in GeV ATTPCIonGenerator* ionGen = new ATTPCIonGenerator("Ion",z,a,q,m,px,py,pz,BExcEner,Bmass,NomEnergy); ionGen->SetSpotRadius(0,-100,0); // add the ion generator primGen->AddGenerator(ionGen); //primGen->SetBeam(1,1,0,0); //These parameters change the position of the vertex of every track added to the Primary Generator // primGen->SetTarget(30,0); // Variables for 2-Body kinematics reaction std::vector<Int_t> Zp; // Zp std::vector<Int_t> Ap; // Ap std::vector<Int_t> Qp;//Electric charge Int_t mult; //Number of particles std::vector<Double_t> Pxp; //Px momentum X std::vector<Double_t> Pyp; //Py momentum Y std::vector<Double_t> Pzp; //Pz momentum Z std::vector<Double_t> Mass; // Masses std::vector<Double_t> ExE; // Excitation energy Double_t ResEner; // Energy of the beam (Useless for the moment) // Note: Momentum will be calculated from the phase Space according to the residual energy of the beam mult = 4; //Number of Nuclei involved in the reaction (Should be always 4) THIS DEFINITION IS MANDATORY (and the number of particles must be the same) ResEner = 0.0; // Useless // ---- Beam ---- Zp.push_back(z); // TRACKID=0 Ap.push_back(a); // Qp.push_back(q); Pxp.push_back(px); Pyp.push_back(py); Pzp.push_back(pz); Mass.push_back(Bmass); ExE.push_back(BExcEner); // ---- Target ---- Zp.push_back(2); // Ap.push_back(4); // Qp.push_back(0); // Pxp.push_back(0.0); Pyp.push_back(0.0); Pzp.push_back(0.0); Mass.push_back(3.728401); ExE.push_back(0.0);//In MeV //--- Scattered ----- Zp.push_back(2); // TRACKID=1 Ap.push_back(6); // Qp.push_back(0); Pxp.push_back(0.0); Pyp.push_back(0.0); Pzp.push_back(0.0); Mass.push_back(5.606559); ExE.push_back(0.0); // ---- Recoil ----- Zp.push_back(2); // TRACKID=2 Ap.push_back(6); // Qp.push_back(0); // Pxp.push_back(0.0); Pyp.push_back(0.0); Pzp.push_back(0.0); Mass.push_back(5.606559); ExE.push_back(0.0);//In MeV Double_t ThetaMinCMS = 0.0; Double_t ThetaMaxCMS = 180.0; ATTPC2Body* TwoBody = new ATTPC2Body("TwoBody",&Zp,&Ap,&Qp,mult,&Pxp,&Pyp,&Pzp,&Mass,&ExE,ResEner, ThetaMinCMS,ThetaMaxCMS); primGen->AddGenerator(TwoBody); run->SetGenerator(primGen); // ------------------------------------------------------------------------ //---Store the visualiztion info of the tracks, this make the output file very large!! //--- Use it only to display but not for production! run->SetStoreTraj(kTRUE); // ----- Initialize simulation run ------------------------------------ run->Init(); // ------------------------------------------------------------------------ // ----- Runtime database --------------------------------------------- Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ------------------------------------------------------------------------ // ----- Start run ---------------------------------------------------- run->Run(nEvents); //You can export your ROOT geometry ot a separate file run->CreateGeometryFile("./data/geofile_proto_full.root"); // ------------------------------------------------------------------------ // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << outFile << endl; cout << "Parameter file is " << parFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; // ------------------------------------------------------------------------ }
void run(TString runNumber) { TStopwatch timer; timer.Start(); const Int_t nev = -1; // number of events to read, -1 - untill CTRL+C TString inDir = "/Volumes/Data/kresan/s438b/lmd/"; // directory with lmd files TString outDir = "/Volumes/Data/kresan/s438b/data/"; // output directory TString histDir = "/Users/kresan/Sites/"; // web-server directory TString outputFileName = outDir + runNumber + "_raw.root"; // name of output file TString histFileName = histDir + "hist_s438b_" + runNumber + "_raw.root"; // name of file with control histograms const Int_t refresh = 100000; // refresh rate for saving control histograms TString parFileName = outDir + "params_" + runNumber + "_raw.root"; // name of parameter file //const Long64_t maxSize = 1 * 1024 * 1024 * 1024; // 1 GByte // file split size const char *landMappingName = "cfg_neuland_s438b.hh"; // mapping file const Int_t nBarsPerPlane = 50; const Int_t updateRate = 150000; const Int_t minStats = 5000; const Int_t nModules = 800; // Create source with unpackers ---------------------------------------------- Int_t iFile = 0; Int_t kFile = 0; if(runNumber.Contains("run331")) { iFile = 5209; kFile = 5229; } FairLmdSource* source = new FairLmdSource(); char strName[1000]; for(Int_t i = iFile; i < kFile; i++) { sprintf(strName, "%s%s_%4d.lmd", inDir.Data(), runNumber.Data(), i); for(Int_t j = 0; j < 1000; j++) if(' ' == strName[j]) strName[j] = '0'; cout << strName << endl; source->AddFile(strName); } R3BEventHeaderUnpack *event_unpack = new R3BEventHeaderUnpack(); source->AddUnpacker(event_unpack); // NeuLAND MBS parameters ------------------------------- Short_t type = 94; Short_t subType = 9400; Short_t procId = 12; Short_t subCrate = 0; Short_t control = 3; source->AddUnpacker(new R3BLandUnpack(type, subType, procId, subCrate, control)); // ------------------------------------------------------ // LOS MBS parameters ----------------------------------- type = 88; subType = 8800; procId = 10; subCrate = 7; control = 5; //source->AddUnpacker(new R3BLosUnpack(type, subType, procId, subCrate, control)); // ------------------------------------------------------ // --------------------------------------------------------------------------- // Create online run --------------------------------------------------------- FairRunOnline* run = new FairRunOnline(source); run->SetOutputFile(outputFileName.Data()); run->SetGenerateHtml(kTRUE, histFileName.Data(), refresh); // --------------------------------------------------------------------------- // Create ALADIN field map --------------------------------------------------- R3BAladinFieldMap* magField = new R3BAladinFieldMap("AladinMaps"); Double_t fMeasCurrent = 2500.; // I_current [A] magField->SetCurrent(fMeasCurrent); magField->SetScale(1.); run->SetField(magField); // --------------------------------------------------------------------------- // Channel mapping ----------------------------------------------------------- R3BLandMapping* map = new R3BLandMapping(); map->SetFileName(landMappingName); map->SetNofBarsPerPlane(nBarsPerPlane); run->AddTask(map); // --------------------------------------------------------------------------- // TCAL ---------------------------------------------------------------------- R3BLandTcalFill* tcalFill = new R3BLandTcalFill("TcalFill"); tcalFill->SetUpdateRate(updateRate); tcalFill->SetMinStats(minStats); tcalFill->SetTrigger(2); tcalFill->SetNofModules(nModules, 50); run->AddTask(tcalFill); R3BLosTcalFill* losTcalFill = new R3BLosTcalFill("LosTcalFill"); losTcalFill->SetUpdateRate(updateRate); losTcalFill->SetMinStats(minStats); losTcalFill->SetNofModules(20); //run->AddTask(losTcalFill); // --------------------------------------------------------------------------- // Add analysis task --------------------------------------------------------- R3BLandRawAna* ana = new R3BLandRawAna("LandRawAna", 1); run->AddTask(ana); // --------------------------------------------------------------------------- // Initialize ---------------------------------------------------------------- run->Init(); //((TTree*)gFile->Get("cbmsim"))->SetMaxTreeSize(maxSize); FairLogger::GetLogger()->SetLogScreenLevel("INFO"); // --------------------------------------------------------------------------- // Runtime data base --------------------------------------------------------- FairRuntimeDb* rtdb = run->GetRuntimeDb(); R3BFieldPar* fieldPar = (R3BFieldPar*)rtdb->getContainer("R3BFieldPar"); fieldPar->SetParameters(magField); fieldPar->setChanged(); Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFileName); rtdb->setOutput(parOut); rtdb->print(); // --------------------------------------------------------------------------- // Run ----------------------------------------------------------------------- run->Run(nev, 0); rtdb->saveOutput(); // --------------------------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << outputFileName << endl; cout << "Parameter file is " << parFileName << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; }
/******************************************************************************** * Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH * * * * This software is distributed under the terms of the * * GNU Lesser General Public Licence version 3 (LGPL) version 3, * * copied verbatim in the file "LICENSE" * ********************************************************************************/ void run_tutorial1_mesh(Int_t nEvents = 10, TString mcEngine = "TGeant3") { TString dir = getenv("VMCWORKDIR"); TString tutdir = dir + "/Tutorial1"; TString tut_geomdir = dir + "/geometry"; gSystem->Setenv("GEOMPATH",tut_geomdir.Data()); TString tut_configdir = dir + "/gconfig"; gSystem->Setenv("CONFIG_DIR",tut_configdir.Data()); TString partName[] = {"pions","eplus","proton"}; Int_t partPdgC[] = { 211, 11, 2212}; Int_t chosenPart = 0; Double_t momentum = 2.; Double_t theta = 0.; TString outDir = "./"; // Output file name TString outFile = Form("%s/tutorial1_mesh%s_%s.mc_p%1.3f_t%1.0f_n%d.root", outDir.Data(), mcEngine.Data(), partName[chosenPart].Data(), momentum, theta, nEvents); // Parameter file name TString parFile = Form("%s/tutorial1_mesh%s_%s.params_p%1.3f_t%1.0f_n%d.root", outDir.Data(), mcEngine.Data(), partName[chosenPart].Data(), momentum, theta, nEvents); // In general, the following parts need not be touched // ======================================================================== // ---- Debug option ------------------------------------------------- gDebug = 0; // ------------------------------------------------------------------------ // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ------------------------------------------------------------------------ // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName(mcEngine); // Transport engine run->SetOutputFile(outFile); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // ------------------------------------------------------------------------ // ----- Create media ------------------------------------------------- run->SetMaterials("media.geo"); // Materials // ------------------------------------------------------------------------ // ----- Create geometry ---------------------------------------------- FairModule* cave= new FairCave("CAVE"); cave->SetGeometryFileName("cave_vacuum.geo"); run->AddModule(cave); FairDetector* tutdet = new FairTutorialDet1("TUTDET", kTRUE); tutdet->SetGeometryFileName("double_sector.geo"); run->AddModule(tutdet); // ------------------------------------------------------------------------ // ----- Create PrimaryGenerator -------------------------------------- FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); FairBoxGenerator* boxGen = new FairBoxGenerator(partPdgC[chosenPart], 1); boxGen->SetThetaRange ( theta, theta+0.01); boxGen->SetPRange (momentum,momentum+0.01); boxGen->SetPhiRange (0.,360.); boxGen->SetDebug(kTRUE); primGen->AddGenerator(boxGen); run->SetGenerator(primGen); // ------------------------------------------------------------------------ run->SetStoreTraj(kFALSE); // to store particle trajectories run->SetRadGridRegister(kTRUE); // activate RadGridManager // define two example meshs for dosimetry FairMesh* aMesh1 = new FairMesh("test1"); aMesh1->SetX(-40,40,200); aMesh1->SetY(-40,40,200); aMesh1->SetZ(5.2,5.4,1); FairMesh* aMesh2 = new FairMesh("test2"); aMesh2->SetX(-20,20,20); aMesh2->SetY(-20,20,20); aMesh2->SetZ(-5.0,5.0,1); aMesh1->print(); aMesh2->print(); run->AddMesh( aMesh1 ); run->AddMesh( aMesh2 ); // ----- Initialize simulation run ------------------------------------ run->Init(); // ------------------------------------------------------------------------ // ----- Runtime database --------------------------------------------- Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ------------------------------------------------------------------------ // ----- Start run ---------------------------------------------------- run->Run(nEvents); // ------------------------------------------------------------------------ // ----- Finish ------------------------------------------------------- cout << endl << endl; // Extract the maximal used memory an add is as Dart measurement // This line is filtered by CTest and the value send to CDash FairSystemInfo sysInfo; Float_t maxMemory=sysInfo.GetMaxMemory(); cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">"; cout << maxMemory; cout << "</DartMeasurement>" << endl; timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); Float_t cpuUsage=ctime/rtime; cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">"; cout << cpuUsage; cout << "</DartMeasurement>" << endl; cout << endl << endl; cout << "Output file is " << outFile << endl; cout << "Parameter file is " << parFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; cout << "Macro finished successfully." << endl; // ------------------------------------------------------------------------ }
void analysis_pbarp_Xi_test(int nevts=0){ TDatabasePDG::Instance()-> AddParticle("pbarpSystem","pbarpSystem", 1.9, kFALSE, 0.1, 0,"", 88888); TStopwatch timer; //Output File TString Path = "/private/puetz/mysimulations/analysis/pbarp_Xiplus_Ximinus/idealtracking/10000_events/"; TString outPath = Path; TString OutputFile = outPath + "analysis_output_test.root"; //Input simulation Files TString inPIDFile = Path + "pid_complete.root"; TString inParFile = Path + "simparams.root"; TString PIDParFile = TString( gSystem->Getenv("VMCWORKDIR")) + "/macro/params/all.par"; //Initialization FairLogger::GetLogger()->SetLogToFile(kFALSE); FairRunAna* RunAna = new FairRunAna(); FairRuntimeDb* rtdb = RunAna->GetRuntimeDb(); RunAna->SetInputFile(inPIDFile); //setup parameter database FairParRootFileIo* parIo = new FairParRootFileIo(); parIo->open(inParFile); FairParAsciiFileIo* parIoPID = new FairParAsciiFileIo(); parIoPID->open(PIDParFile.Data(),"in"); rtdb->setFirstInput(parIo); rtdb->setSecondInput(parIoPID); rtdb->setOutput(parIo); RunAna->SetOutputFile(OutputFile); RunAna->Init(); //*** create tuples RhoTuple * ntpMC = new RhoTuple("ntpMC", "MCTruth info"); RhoTuple * ntpPiMinus = new RhoTuple("ntpPiMinus", "PiMinus info"); RhoTuple * ntpPiPlus = new RhoTuple("ntpPiPlus", "PiPlus info"); RhoTuple * ntpProton = new RhoTuple("ntpProton", "Proton info"); RhoTuple * ntpAntiProton = new RhoTuple("ntpAntiProton", "Antiproton info"); RhoTuple * ntpLambda0 = new RhoTuple("ntpLambda0", "Lambda0 info"); RhoTuple * ntpAntiLambda0 = new RhoTuple("ntpAntiLambda0", "AntiLambda0 info"); RhoTuple * ntpXiMinus = new RhoTuple("ntpXiMinus", "XiMinus info"); RhoTuple * ntpXiPlus = new RhoTuple("ntpXiPlus", "XiPlus info"); RhoTuple * ntpXiSys = new RhoTuple("ntpXiSys", "XiMinus XiPlus system info"); //Create output file TFile *out = TFile::Open(outPath+"output_ana_test.root","RECREATE"); // data reader Object PndAnalysis* theAnalysis = new PndAnalysis(); if (nevts==0) nevts = theAnalysis->GetEntries(); //RhoCandLists for analysis RhoCandList piplus, piminus, lambda0, antiLambda0, proton, antiProton, xiplus, ximinus, xiSys; RhoCandList NotCombinedPiMinus, CombinedPiMinus, CombinedPiPlus, NotCombinedPiPlus; RhoCandList SelectedProton, SelectedAntiProton, SelectedPiMinus, SelectedPiPlus; RhoCandList Lambda0Fit, AntiLambda0Fit, XiMinusFit, XiPlusFit; RhoCandList mclist, all; //Dummy RhoCandidate RhoCandidate * dummyCand = new RhoCandidate(); //***Mass selector double m0_lambda0= TDatabasePDG::Instance()->GetParticle("Lambda0")->Mass(); cout<<"Mass of Lambda0: "<<m0_lambda0<<endl; RhoMassParticleSelector * lambdaMassSelector = new RhoMassParticleSelector("lambda0", m0_lambda0, 0.3); double m0_Xi = TDatabasePDG::Instance()->GetParticle("Xi-")->Mass(); cout<<"Mass of Xi-: "<<m0_Xi<<endl; RhoMassParticleSelector * xiMassSelector = new RhoMassParticleSelector("Xi-", m0_Xi, 0.3); double m0_pbarpsystem = TDatabasePDG::Instance()->GetParticle("pbarpSystem")->Mass(); double pbarmom = 2.7; double p_m0 = TDatabasePDG::Instance()->GetParticle("proton")->Mass(); TLorentzVector ini (0,0, pbarmom, sqrt(p_m0*p_m0+ pbarmom*pbarmom)+p_m0); TVector3 beamBoost = ini.BoostVector(); PndRhoTupleQA qa(theAnalysis, pbarmom); int evt=-1; int index=0; while (theAnalysis->GetEvent() && ++evt<nevts){ if ((evt%100)==0) cout << "evt "<< evt <<endl; cout << "Running event " << evt << endl; //***get MC list and store info theAnalysis->FillList(mclist, "McTruth"); qa.qaMcList("", mclist, ntpMC); ntpMC->DumpData(); //if you want to print the hole MCTree uncomment the following /* for (int j=0;j<mclist.GetLength();++j) { RhoCandidate *mcmother = mclist[j]->TheMother(); // mother of mc particle int muid = (mcmother==0x0) ? -1 : mcmother->GetTrackNumber(); // track ID of mother, if existing cout << "Track "<< mclist[j]->GetTrackNumber()<<" (PDG:"<<mclist[j]->PdgCode() <<") has mother "<<muid; if (mclist[j]->NDaughters()>0) cout <<" and daughter(s) "; for (k=0;k<mclist[j]->NDaughters();++k) cout <<mclist[j]->Daughter(k)->GetTrackNumber()<<" "; cout<<endl; }*/ //***Setup event shape object TString PidSelection = "PidAlgoIdealCharged";//"PidAlgoMvd;PidAlgoStt;PidAlgoDrc"; theAnalysis->FillList(all, "All", PidSelection); PndEventShape evsh(all, ini, 0.05, 0.1); //***Selection with no PID info theAnalysis->FillList(piminus, "PionAllMinus", PidSelection); // theAnalysis->FillList(NotCombinedPiMinus, "PionAllMinus", PidSelection); // theAnalysis->FillList(NotCombinedPiPlus, "PionAllPlus", PidSelection); theAnalysis->FillList(piplus, "PionAllPlus", PidSelection); theAnalysis->FillList(proton, "ProtonAllPlus", PidSelection); theAnalysis->FillList(antiProton, "ProtonAllMinus", PidSelection); for (int pip=0; pip<piplus.GetLength(); ++pip){ ntpPiPlus->Column("ev", (Float_t) evt); ntpPiPlus->Column("cand", (Float_t) pip); ntpPiPlus->Column("ncand", (Float_t) piplus.GetLength()); ntpPiPlus->Column("McTruthMatch", (bool) theAnalysis->McTruthMatch(piplus[pip])); qa.qaP4("PiPlus_", piplus[pip]->P4(), ntpPiPlus); qa.qaCand("PiPlus_", piplus[pip], ntpPiPlus); jenny::numberOfHitsInSubdetector("PiPlus_", piplus[pip], ntpPiPlus); jenny::tagNHits("PiPlus_", piplus[pip], ntpPiPlus); int tag = jenny::tagHits(piplus[pip]); RhoCandidate * mother_pip = piplus[pip]->GetMcTruth()->TheMother(); int moth_pip = (0x0==mother_pip)? 88888 : mother_pip->PdgCode(); ntpPiPlus->Column("Mother", (Float_t) moth_pip); ntpPiPlus->Column("PiPlus_CosTheta", (Float_t) piplus[pip]->GetMomentum().CosTheta()); qa.qaP4("PiPlus_MC_", piplus[pip]->GetMcTruth()->P4(), ntpPiPlus); qa.qaCand("PiPlus_MC_", piplus[pip]->GetMcTruth(), ntpPiPlus); ntpPiPlus->Column("PiPlus_MC_CosTheta", (Float_t) piplus[pip]->GetMcTruth()->GetMomentum().CosTheta()); if(tag==1){ SelectedPiPlus.Append(piplus[pip]); NotCombinedPiPlus.Append(piplus[pip]); } ntpPiPlus->DumpData(); } for (int pim=0; pim<piminus.GetLength(); ++pim){ ntpPiMinus->Column("ev", (Float_t) evt); ntpPiMinus->Column("cand", (Float_t) pim); ntpPiMinus->Column("ncand", (Float_t) piminus.GetLength()); ntpPiMinus->Column("McTruthMatch", (bool) theAnalysis->McTruthMatch(piminus[pim])); qa.qaP4("piminus_", piminus[pim]->P4(), ntpPiMinus); qa.qaCand("piminus_", piminus[pim], ntpPiMinus); jenny::numberOfHitsInSubdetector("piminus_", piminus[pim], ntpPiMinus); jenny::tagNHits("piminus_", piminus[pim], ntpPiMinus); int tag = jenny::tagHits(piminus[pim]); RhoCandidate * mother_pim = piminus[pim]->GetMcTruth()->TheMother(); int moth_pim = (0x0==mother_pim)? 88888 : mother_pim->PdgCode(); ntpPiMinus->Column("Mother", (Float_t) moth_pim); ntpPiMinus->Column("PiMinus_CosTheta", (Float_t) piminus[pim]->GetMomentum().CosTheta()); qa.qaP4("piminus_MC_", piminus[pim]->GetMcTruth()->P4(), ntpPiMinus); qa.qaCand("piminus_MC_", piminus[pim]->GetMcTruth(), ntpPiMinus); ntpPiMinus->Column("piminus_MC_CosTheta", (Float_t) piminus[pim]->GetMcTruth()->GetMomentum().CosTheta()); ntpPiMinus->DumpData(); if(tag==1){ SelectedPiMinus.Append(piminus[pim]); NotCombinedPiMinus.Append(piminus[pim]); } } for (int prot=0; prot<proton.GetLength(); ++prot){ ntpProton->Column("ev", (Float_t) evt); ntpProton->Column("cand", (Float_t) prot); ntpProton->Column("ncand", (Float_t) proton.GetLength()); ntpProton->Column("McTruthMatch", (bool) theAnalysis->McTruthMatch(proton[prot])); qa.qaP4("proton_", proton[prot]->P4(), ntpProton); qa.qaCand("proton_", proton[prot], ntpProton); jenny::numberOfHitsInSubdetector("proton_", proton[prot], ntpProton); // jenny::tagNHits("proton_", proton[prot], ntpProton); int tag = jenny::tagHits(proton[prot]); RhoCandidate * mother_prot = proton[prot]->GetMcTruth()->TheMother(); int moth_prot = (0x0==mother_prot)? 88888 : mother_prot->PdgCode(); ntpProton->Column("Mother", (Float_t) moth_prot); ntpProton->Column("proton_CosTheta", (Float_t) proton[prot]->GetMomentum().CosTheta()); qa.qaP4("proton_MC_", proton[prot]->GetMcTruth()->P4(), ntpProton); qa.qaCand("proton_", proton[prot]->GetMcTruth(), ntpProton); ntpProton->Column("proton_MC_CosTheta", (Float_t) proton[prot]->GetMcTruth()->GetMomentum().CosTheta()); ntpProton->DumpData(); if(tag==1) SelectedProton.Append(proton[prot]); } for (int aProt=0; aProt<antiProton.GetLength(); ++aProt){ ntpAntiProton->Column("ev", (Float_t) evt); ntpAntiProton->Column("cand", (Float_t) aProt); ntpAntiProton->Column("ncand", (Float_t) antiProton.GetLength()); ntpAntiProton->Column("McTruthMatch", (bool) theAnalysis->McTruthMatch(antiProton[aProt])); qa.qaP4("antiProton_", antiProton[aProt]->P4(), ntpAntiProton); qa.qaCand("antiProton_", antiProton[aProt], ntpAntiProton); jenny::numberOfHitsInSubdetector("antiProton_", antiProton[aProt], ntpAntiProton); // jenny::tagNHits("antiProton_", antiProton[aProt], ntpAntiProton); int tag = jenny::tagHits(antiProton[aProt]); RhoCandidate * mother_aProt = antiProton[aProt]->GetMcTruth()->TheMother(); int moth_aProt = (0x0==mother_aProt)? 88888 : mother_aProt->PdgCode(); ntpAntiProton->Column("Mother", (Float_t) moth_aProt); ntpAntiProton->Column("antiProton_CosTheta", (Float_t) antiProton[aProt]->GetMomentum().CosTheta()); qa.qaP4("antiProton_MC_", antiProton[aProt]->GetMcTruth()->P4(), ntpAntiProton); qa.qaCand("antiProton_", antiProton[aProt]->GetMcTruth(), ntpAntiProton); ntpAntiProton->Column("antiProton_MC_CosTheta", (Float_t) antiProton[aProt]->GetMcTruth()->GetMomentum().CosTheta()); ntpAntiProton->DumpData(); if(tag==1) SelectedAntiProton.Append(antiProton[aProt]); } //***Lambda0 -> PiMinus + Proton lambda0.Combine(SelectedPiMinus,SelectedProton); lambda0.Select(lambdaMassSelector); lambda0.SetType(kl0); std::map<int,int> bestVtxFitLambda0, bestMassFitLambda0; bestVtxFitLambda0 = jenny::VertexQaIndex(&lambda0); bestMassFitLambda0 = jenny::MassFitQaIndex(&lambda0, m0_lambda0); for (int j=0; j<lambda0.GetLength(); ++j){ //general info about event ntpLambda0->Column("ev", (Float_t) evt); ntpLambda0->Column("cand", (Float_t) j); ntpLambda0->Column("ncand", (Float_t) lambda0.GetLength()); ntpLambda0->Column("McTruthMatch", (bool) theAnalysis->McTruthMatch(lambda0[j])); ntpLambda0->Column("Lambda0_Pdg", (Float_t) lambda0[j]->PdgCode()); RhoCandidate * mother = lambda0[j]->TheMother(); int moth = (mother==0x0) ? 88888 : mother->PdgCode(); ntpLambda0->Column("Mother", (Float_t) moth); qa.qaP4("Lambda0_", lambda0[j]->P4(), ntpLambda0); qa.qaComp("Lambda0_", lambda0[j], ntpLambda0); // do vertex fit PndKinVtxFitter vertexfitterLambda0 (lambda0[j]); vertexfitterLambda0.Fit(); RhoCandidate * lambda0Fit = lambda0[j]->GetFit(); // store info of vertex fit qa.qaFitter("VtxFit_", &vertexfitterLambda0, ntpLambda0); ntpLambda0->Column("VtxFit_HowGood", (Int_t) bestVtxFitLambda0[j]); qa.qaVtx("VtxFit_", lambda0Fit, ntpLambda0); // differenz to MCTruth qa.qaMcDiff("fvtxMcDiff_", lambda0Fit, ntpLambda0); // do mass fit PndKinFitter massFitterLambda0(lambda0Fit); massFitterLambda0.AddMassConstraint(m0_lambda0); massFitterLambda0.Fit(); RhoCandidate * lambda0Fit_mass = lambda0Fit->GetFit(); qa.qaFitter("MassFit_", &massFitterLambda0, ntpLambda0); ntpLambda0->Column("MassFit_HowGood", (Int_t) bestMassFitLambda0[j]); RhoCandidate * truth = lambda0[j]->GetMcTruth(); RhoCandidate * truthDaughter = lambda0[j]->Daughter(0)->GetMcTruth(); TLorentzVector l; TVector3 dl; if(0x0 != truth){ l = truth->P4(); qa.qaVtx("McTruth_", truth, ntpLambda0); dl = truth->Daughter(0)->Pos(); } else{ qa.qaVtx("McTruth_", dummyCand, ntpLambda0); } jenny::qaP3("McTruth_", dl, ntpLambda0); qa.qaP4("McTruth_", l, ntpLambda0); //*** use for Xi only bestChi2Cand if (bestVtxFitLambda0[j]==1 && bestMassFitLambda0[j]>0){ Lambda0Fit.Append(lambda0Fit); jenny::CombinedList(lambda0Fit, &CombinedPiMinus, -211); } //***information of boosted particle lambda0Fit->Boost(-beamBoost); qa.qaComp("boost_", lambda0Fit, ntpLambda0); ntpLambda0->DumpData(); } jenny::GetNotCombinedList(CombinedPiMinus, &NotCombinedPiMinus); // Lambda0Fit.Cleanup(); CombinedPiMinus.Cleanup(); SelectedPiMinus.Cleanup(); SelectedProton.Cleanup(); // NotCombinedPiMinus.Cleanup(); bestVtxFitLambda0.clear(); bestMassFitLambda0.clear(); //***AntiLambda0 -> PiPlus + AntiProton antiLambda0.Combine(SelectedPiPlus,SelectedAntiProton); antiLambda0.Select(lambdaMassSelector); antiLambda0.SetType(kal0); std::map<int,int> bestVtxFitAntiLambda0, bestMassFitAntiLambda0; bestVtxFitAntiLambda0 = jenny::VertexQaIndex(&antiLambda0); bestMassFitAntiLambda0 = jenny::MassFitQaIndex(&antiLambda0, m0_lambda0); for (int j=0; j<antiLambda0.GetLength(); ++j){ //general info about event ntpAntiLambda0->Column("ev", (Float_t) evt); ntpAntiLambda0->Column("cand", (Float_t) j); ntpAntiLambda0->Column("ncand", (Float_t) antiLambda0.GetLength()); ntpAntiLambda0->Column("McTruthMatch", (bool) theAnalysis->McTruthMatch(antiLambda0[j])); ntpAntiLambda0->Column("AntiLambda0_Pdg", (Float_t) antiLambda0[j]->PdgCode()); RhoCandidate * mother = antiLambda0[j]->TheMother(); int moth = (mother==0x0) ? 88888 : mother->PdgCode(); ntpAntiLambda0->Column("Mother", (Float_t) moth); qa.qaP4("AntiLambda0_", antiLambda0[j]->P4(), ntpAntiLambda0); qa.qaComp("AntiLambda0_", antiLambda0[j], ntpAntiLambda0); // do vertex fit PndKinVtxFitter vertexfitterAntiLambda0 (antiLambda0[j]); vertexfitterAntiLambda0.Fit(); RhoCandidate * antiLambda0Fit = antiLambda0[j]->GetFit(); // store info of vertex fit qa.qaFitter("VtxFit_", &vertexfitterAntiLambda0, ntpAntiLambda0); qa.qaVtx("VtxFit_", antiLambda0Fit, ntpAntiLambda0); ntpAntiLambda0->Column("VtxFit_HowGood", (Int_t) bestVtxFitAntiLambda0[j]); // do mass fit PndKinFitter massFitterAntiLambda0(antiLambda0Fit); massFitterAntiLambda0.AddMassConstraint(m0_lambda0); massFitterAntiLambda0.Fit(); RhoCandidate * antiLambda0Fit_mass = antiLambda0Fit->GetFit(); qa.qaFitter("MassFit_", &massFitterAntiLambda0, ntpAntiLambda0); ntpAntiLambda0->Column("MassFit_HowGood", (Int_t) bestMassFitAntiLambda0[j]); RhoCandidate * truth = antiLambda0[j]->GetMcTruth(); TLorentzVector l; if(0x0 != truth){ l = truth->P4(); qa.qaVtx("MCTruth_", truth, ntpAntiLambda0); } else{ qa.qaVtx("McTruth_", dummyCand, ntpAntiLambda0); } qa.qaP4("MCTruth_", l, ntpAntiLambda0); //***information of boosted particle antiLambda0Fit->Boost(-beamBoost); qa.qaComp("boost_", antiLambda0Fit, ntpAntiLambda0); if(bestVtxFitAntiLambda0[j]==1 && bestMassFitAntiLambda0[j]>0){ AntiLambda0Fit.Append(antiLambda0Fit); jenny::CombinedList(antiLambda0Fit, &CombinedPiPlus, 211); } ntpAntiLambda0->DumpData(); } jenny::GetNotCombinedList(CombinedPiPlus, &NotCombinedPiPlus); CombinedPiPlus.Cleanup(); SelectedPiPlus.Cleanup(); SelectedAntiProton.Cleanup(); bestVtxFitAntiLambda0.clear(); bestMassFitAntiLambda0.clear(); //*** Xi- -> Lambda0 + Pi- ximinus.Combine(Lambda0Fit, NotCombinedPiMinus); ximinus.Select(xiMassSelector); ximinus.SetType(kXim); std::map<int,int> BestVtxFitXiMinus, BestMassFitXiMinus; BestVtxFitXiMinus = jenny::VertexQaIndex(&ximinus); BestMassFitXiMinus = jenny::MassFitQaIndex(&ximinus, m0_Xi); for (int j=0; j<ximinus.GetLength(); ++j){ //general info about event ntpXiMinus->Column("ev", (Float_t) evt); ntpXiMinus->Column("cand", (Float_t) j); ntpXiMinus->Column("ncand", (Float_t) ximinus.GetLength()); ntpXiMinus->Column("McTruthMatch", (bool) theAnalysis->McTruthMatch(ximinus[j])); ntpXiMinus->Column("XiMinus_Pdg", (Float_t) ximinus[j]->PdgCode()); RhoCandidate * mother = ximinus[j]->TheMother(); int moth = (mother==0x0) ? 88888 : mother->PdgCode(); ntpXiMinus->Column("Mother", (Float_t) moth); qa.qaP4("XiMinus_", ximinus[j]->P4(), ntpXiMinus); qa.qaComp("XiMinus_", ximinus[j], ntpXiMinus); qa.qaPoca("XiMinus_", ximinus[j], ntpXiMinus); // do vertex-fit PndKinVtxFitter vertexfitterXiMinus (ximinus[j]); vertexfitterXiMinus.Fit(); RhoCandidate * ximinusFit = ximinus[j]->GetFit(); // store info of vertex-fit qa.qaFitter("VtxFit_", &vertexfitterXiMinus, ntpXiMinus); ntpXiMinus->Column("VtxFit_HowGood", (Int_t) BestVtxFitXiMinus[j]); qa.qaVtx("VtxFit_", ximinusFit, ntpXiMinus); // qa.Cand("VtxFit_", ximinusFit, ntpXiMinus); // difference to MCTruth qa.qaMcDiff("VtxFit_", ximinusFit, ntpXiMinus); // do mass fit PndKinFitter massFitterXiMinus(ximinusFit); massFitterXiMinus.AddMassConstraint(m0_lambda0); massFitterXiMinus.Fit(); RhoCandidate * ximinusFit_mass = ximinusFit->GetFit(); qa.qaFitter("MassFit_", &massFitterXiMinus, ntpXiMinus); ntpXiMinus->Column("MassFit_HowGood", (Int_t) BestMassFitXiMinus[j]); qa.qaMcDiff("MassFit_", ximinusFit_mass, ntpXiMinus); RhoCandidate * truth = ximinus[j]->GetMcTruth(); TLorentzVector l; if(0x0 != truth){ l = truth->P4(); qa.qaVtx("MCTruth_", truth, ntpXiMinus); } else{ qa.qaVtx("MCTruth_", dummyCand, ntpXiMinus); } qa.qaP4("MCTruth_", l, ntpXiMinus); if (BestVtxFitXiMinus[j]==1 && BestMassFitXiMinus[j]>0){ XiMinusFit.Append(ximinusFit); } //***information of boosted particle ximinusFit->Boost(-beamBoost); qa.qaComp("boost_", ximinusFit, ntpXiMinus); ntpXiMinus->DumpData(); } Lambda0Fit.Cleanup(); NotCombinedPiMinus.Cleanup(); BestVtxFitXiMinus.clear(); BestMassFitXiMinus.clear(); //*** Xi+ -> AntiLambda0 + Pi+ xiplus.Combine(AntiLambda0Fit,piplus); xiplus.Select(xiMassSelector); xiplus.SetType(kaXip); std::map<int,int> BestVtxFitXiPlus, BestMassFitXiPlus; BestVtxFitXiPlus = jenny::VertexQaIndex(&xiplus); BestMassFitXiPlus = jenny::MassFitQaIndex(&xiplus, m0_Xi); for (int j=0; j<xiplus.GetLength(); ++j){ //general info about event ntpXiPlus->Column("ev", (Float_t) evt); ntpXiPlus->Column("cand", (Float_t) j); ntpXiPlus->Column("ncand", (Float_t) xiplus.GetLength()); ntpXiPlus->Column("McTruthMatch", (bool) theAnalysis->McTruthMatch(xiplus[j])); RhoCandidate * mother = xiplus[j]->TheMother(); int moth = (mother==0x0) ? 88888 : mother->PdgCode(); ntpXiPlus->Column("Mother", (Float_t) moth); qa.qaP4("Xiplus_", xiplus[j]->P4(), ntpXiPlus); qa.qaComp("Xiplus_", xiplus[j], ntpXiPlus); // int tag = 0; // int dtag[2] = {0,0}; // // for (int dau=0; dau<xiplus[j]->NDaughters(); dau++){ // // RhoCandidate * daughter = xiplus[j]->Daughter(dau); // if(daughter->IsComposite()){ // int dtag1 = jenny::tagHits(daughter->Daughter(0)); // int dtag2 = jenny::tagHits(daughter->Daughter(1)); // if(dtag1==1 && dtag2==1) dtag[dau]=1; // } // else{ // dtag[dau] = jenny::tagHits(daughter); // } // } // // if(dtag[0]==1 && dtag[1]==1) tag=1; // // ntpXiPlus->Column("XiPlus_HitTag", (Int_t) tag); //******** do vertex-fit PndKinVtxFitter vertexfitterxiplus (xiplus[j]); vertexfitterxiplus.Fit(); RhoCandidate * xiplusFit = xiplus[j]->GetFit(); // store info of vertex-fit qa.qaFitter("VtxFit_", &vertexfitterxiplus, ntpXiPlus); ntpXiPlus->Column("VtxFit_HowGood", (Int_t) BestVtxFitXiPlus[j]); qa.qaVtx("VtxFit_", xiplusFit, ntpXiPlus); // difference to MCTruth qa.qaMcDiff("VtxFit_", xiplusFit, ntpXiPlus); //****** do mass fit PndKinFitter massFitterxiplus(xiplusFit); massFitterxiplus.AddMassConstraint(m0_lambda0); massFitterxiplus.Fit(); RhoCandidate * xiplusFit_mass = xiplusFit->GetFit(); qa.qaFitter("MassFit_", &massFitterxiplus, ntpXiPlus); ntpXiPlus->Column("MassFit_HowGood", (float) BestMassFitXiPlus[j]); qa.qaVtx("MassFit_", xiplusFit_mass, ntpXiPlus); qa.qaMcDiff("MassFit_", xiplusFit_mass, ntpXiPlus); RhoCandidate * truth = xiplus[j]->GetMcTruth(); TLorentzVector l; if(0x0 != truth){ l = truth->P4(); qa.qaVtx("MCTruth_", truth, ntpXiPlus); } else{ qa.qaVtx("MCTruth_", dummyCand, ntpXiPlus); } qa.qaP4("MCTruth_", l, ntpXiPlus); if(BestVtxFitXiPlus[j]==1 && BestMassFitXiPlus[j]>0){ XiPlusFit.Append(xiplusFit); } //***information of boosted particle xiplusFit->Boost(-beamBoost); qa.qaComp("boost_", xiplusFit, ntpXiPlus); ntpXiPlus->DumpData(); } AntiLambda0Fit.Cleanup(); // BestCandAntiLambda0.Cleanup(); BestVtxFitXiPlus.clear(); BestMassFitXiPlus.clear(); //******* Xi+ Xi- System***************************** xiSys.Combine(XiPlusFit, XiMinusFit); xiSys.SetType(88888); for (int syscand=0; syscand<xiSys.GetLength(); ++syscand){ ntpXiSys->Column("ev", (Float_t) evt); ntpXiSys->Column("cand", (Float_t) j); ntpXiSys->Column("ncand", (Float_t) ximinus.GetLength()); ntpXiSys->Column("McTruthMatch", (bool) theAnalysis->McTruthMatch(xiSys[syscand])); RhoCandidate * mother = xiSys[syscand]->TheMother(); int moth = (mother==0x0) ? 88888 : mother->PdgCode(); ntpXiSys->Column("Mother", (Float_t) moth); qa.qaP4("XiSys_", xiSys[syscand]->P4(), ntpXiSys); qa.qaComp("XiSys_", xiSys[syscand], ntpXiSys); qa.qaPoca("XiSys_", xiSys[syscand], ntpXiSys); RhoCandidate * truth = xiSys[syscand]->GetMcTruth(); TLorentzVector l; if (truth != 0x0){ // qa.qaComp("McTruth_", truth, ntpXiSys); qa.qaVtx("McTruth_", truth, ntpXiSys); l = truth->P4(); } else{ // qa.qaComp("McTruth_", dummyCand, ntpXiSys); qa.qaVtx("McTruth_", dummyCand, ntpXiSys); } qa.qaP4("McTruth_", l, ntpXiSys); //4C-Fitter PndKinFitter fitter4c (xiSys[syscand]); fitter4c.Add4MomConstraint(ini); fitter4c.Fit(); RhoCandidate * xiSysFit4c = xiSys[syscand]->GetFit(); qa.qaFitter("4CFit_", &fitter4c, ntpXiSys); qa.qaComp("4cFit_", xiSysFit4c, ntpXiSys); qa.qaVtx("4CFit_", xiSysFit4c, ntpXiSys); ntpXiSys->DumpData(); } XiMinusFit.Cleanup(); XiPlusFit.Cleanup(); } //Write output out->cd(); ntpMC -> GetInternalTree()->Write(); ntpPiMinus ->GetInternalTree()->Write(); ntpPiPlus->GetInternalTree()->Write(); ntpProton->GetInternalTree()->Write(); ntpAntiProton->GetInternalTree()->Write(); ntpLambda0->GetInternalTree()->Write(); ntpAntiLambda0->GetInternalTree()->Write(); ntpXiMinus->GetInternalTree()->Write(); ntpXiPlus->GetInternalTree()->Write(); ntpXiSys->GetInternalTree()->Write(); out->Save(); timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout<<endl<<endl; cout<<"Macro finisched successfully."<<endl; cout<<"Realtime: "<<rtime<<" s, CPU time: "<<ctime<<" s"<<endl; cout<<endl; exit(0); }
void r3ball(Int_t nEvents = 1, TMap& fDetList, TString Target = "LeadTarget", Bool_t fVis = kFALSE, TString fMC = "TGeant3", TString fGenerator = "box", Bool_t fUserPList = kFALSE, Bool_t fR3BMagnet = kTRUE, Bool_t fCalifaHitFinder = kFALSE, Bool_t fStarTrackHitFinder = kFALSE, Double_t fMeasCurrent = 2000., TString OutFile = "r3bsim.root", TString ParFile = "r3bpar.root", TString InFile = "evt_gen.dat", double energy1, double energy2) { TString dir = getenv("VMCWORKDIR"); TString r3bdir = dir + "/macros"; TString r3b_geomdir = dir + "/geometry"; gSystem->Setenv("GEOMPATH",r3b_geomdir.Data()); TString r3b_confdir = dir + "gconfig"; gSystem->Setenv("CONFIG_DIR",r3b_confdir.Data()); // In general, the following parts need not be touched // ======================================================================== // ---- Debug option ------------------------------------------------- gDebug = 0; // ------------------------------------------------------------------------ // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ------------------------------------------------------------------------ // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName(fMC.Data()); // Transport engine run->SetOutputFile(OutFile.Data()); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); FairLogger::GetLogger()->SetLogScreenLevel("DEBUG"); // R3B Special Physics List in G4 case if ( (fUserPList == kTRUE ) && (fMC.CompareTo("TGeant4") == 0) ){ run->SetUserConfig("g4R3bConfig.C"); run->SetUserCuts("SetCuts.C"); } // ----- Create media ------------------------------------------------- run->SetMaterials("media_r3b.geo"); // Materials // Magnetic field map type Int_t fFieldMap = 0; // Global Transformations //- Two ways for a Volume Rotation are supported //-- 1) Global Rotation (Euler Angles definition) //-- This represent the composition of : first a rotation about Z axis with //-- angle phi, then a rotation with theta about the rotated X axis, and //-- finally a rotation with psi about the new Z axis. Double_t phi,theta,psi; //-- 2) Rotation in Ref. Frame of the Volume //-- Rotation is Using Local Ref. Frame axis angles Double_t thetaX,thetaY,thetaZ; //- Global Translation Lab. frame. Double_t tx,ty,tz; // ----- Create R3B geometry -------------------------------------------- //R3B Cave definition FairModule* cave= new R3BCave("CAVE"); cave->SetGeometryFileName("r3b_cave.geo"); run->AddModule(cave); //R3B Target definition if (fDetList.FindObject("TARGET") ) { R3BModule* target= new R3BTarget(Target.Data()); target->SetGeometryFileName(((TObjString*)fDetList.GetValue("TARGET"))->GetString().Data()); run->AddModule(target); } //R3B SiTracker Cooling definition if (fDetList.FindObject("VACVESSELCOOL") ) { R3BModule* vesselcool= new R3BVacVesselCool(Target.Data()); vesselcool->SetGeometryFileName(((TObjString*)fDetList.GetValue("VACVESSELCOOL"))->GetString().Data()); run->AddModule(vesselcool); } //R3B Magnet definition if (fDetList.FindObject("ALADIN") ) { fFieldMap = 0; R3BModule* mag = new R3BMagnet("AladinMagnet"); mag->SetGeometryFileName(((TObjString*)fDetList.GetValue("ALADIN"))->GetString().Data()); run->AddModule(mag); } //R3B Magnet definition if (fDetList.FindObject("GLAD") ) { fFieldMap = 1; R3BModule* mag = new R3BGladMagnet("GladMagnet", ((TObjString*)fDetList->GetValue("GLAD"))->GetString(), "GLAD Magnet"); run->AddModule(mag); } if (fDetList.FindObject("CRYSTALBALL") ) { //R3B Crystal Calorimeter R3BDetector* xball = new R3BXBall("XBall", kTRUE); xball->SetGeometryFileName(((TObjString*)fDetList.GetValue("CRYSTALBALL"))->GetString().Data()); run->AddModule(xball); } if (fDetList.FindObject("CALIFA") ) { // CALIFA Calorimeter R3BDetector* califa = new R3BCalifa("Califa", kTRUE); // ((R3BCalifa *)califa)->SelectGeometryVersion(0x438b); ((R3BCalifa *)califa)->SelectGeometryVersion(17); //Selecting the Non-uniformity of the crystals (1 means +-1% max deviation) ((R3BCalifa *)califa)->SetNonUniformity(.0); califa->SetGeometryFileName(((TObjString*)fDetList.GetValue("CALIFA"))->GetString().Data()); run->AddModule(califa); } // Tracker if (fDetList.FindObject("TRACKER") ) { R3BDetector* tra = new R3BTra("Tracker", kTRUE); tra->SetGeometryFileName(((TObjString*)fDetList.GetValue("TRACKER"))->GetString().Data()); run->AddModule(tra); } // STaRTrack if (fDetList.FindObject("STaRTrack") ) { R3BDetector* tra = new R3BSTaRTra("STaRTrack", kTRUE); tra->SetGeometryFileName(((TObjString*)fDetList.GetValue("STaRTrack"))->GetString().Data()); run->AddModule(tra); } // DCH drift chambers if (fDetList.FindObject("DCH") ) { R3BDetector* dch = new R3BDch("Dch", kTRUE); dch->SetGeometryFileName(((TObjString*)fDetList.GetValue("DCH"))->GetString().Data()); run->AddModule(dch); } // Tof if (fDetList.FindObject("TOF") ) { R3BDetector* tof = new R3BTof("Tof", kTRUE); tof->SetGeometryFileName(((TObjString*)fDetList.GetValue("TOF"))->GetString().Data()); run->AddModule(tof); } // mTof if (fDetList.FindObject("MTOF") ) { R3BDetector* mTof = new R3BmTof("mTof", kTRUE); mTof->SetGeometryFileName(((TObjString*)fDetList.GetValue("MTOF"))->GetString().Data()); run->AddModule(mTof); } // GFI detector if (fDetList.FindObject("GFI") ) { R3BDetector* gfi = new R3BGfi("Gfi", kTRUE); gfi->SetGeometryFileName(((TObjString*)fDetList.GetValue("GFI"))->GetString().Data()); run->AddModule(gfi); } // Land Detector if (fDetList.FindObject("LAND") ) { R3BDetector* land = new R3BLand("Land", kTRUE); land->SetVerboseLevel(1); land->SetGeometryFileName(((TObjString*)fDetList.GetValue("LAND"))->GetString().Data()); run->AddModule(land); } // NeuLand Scintillator Detector if(fDetList.FindObject("SCINTNEULAND")) { R3BDetector* land = new R3BLand("Land", kTRUE); land->SetVerboseLevel(1); land->SetGeometryFileName(((TObjString*)fDetList.GetValue("SCINTNEULAND"))->GetString().Data()); run->AddModule(land); } // MFI Detector if(fDetList.FindObject("MFI")) { R3BDetector* mfi = new R3BMfi("Mfi", kTRUE); mfi->SetGeometryFileName(((TObjString*)fDetList.GetValue("MFI"))->GetString().Data()); run->AddModule(mfi); } // PSP Detector if(fDetList.FindObject("PSP")) { R3BDetector* psp = new R3BPsp("Psp", kTRUE); psp->SetGeometryFileName(((TObjString*)fDetList.GetValue("PSP"))->GetString().Data()); run->AddModule(psp); } // Luminosity detector if (fDetList.FindObject("LUMON") ) { R3BDetector* lumon = new ELILuMon("LuMon", kTRUE); lumon->SetGeometryFileName(((TObjString*)fDetList.GetValue("LUMON"))->GetString().Data()); run->AddModule(lumon); } // ----- Create R3B magnetic field ---------------------------------------- Int_t typeOfMagneticField = 0; Int_t fieldScale = 1; Bool_t fVerbose = kFALSE; //NB: <D.B> // If the Global Position of the Magnet is changed // the Field Map has to be transformed accordingly if (fFieldMap == 0) { R3BAladinFieldMap* magField = new R3BAladinFieldMap("AladinMaps"); magField->SetCurrent(fMeasCurrent); magField->SetScale(fieldScale); if ( fR3BMagnet == kTRUE ) { run->SetField(magField); } else { run->SetField(NULL); } } else if(fFieldMap == 1){ R3BGladFieldMap* magField = new R3BGladFieldMap("R3BGladMap"); magField->SetScale(fieldScale); if ( fR3BMagnet == kTRUE ) { run->SetField(magField); } else { run->SetField(NULL); } } //! end of field map section // ----- Create PrimaryGenerator -------------------------------------- // 1 - Create the Main API class for the Generator FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); if (fGenerator.CompareTo("ion") == 0 ) { // R3B Ion Generator Int_t z = 30; // Atomic number Int_t a = 65; // Mass number Int_t q = 0; // Charge State Int_t m = 1; // Multiplicity Double_t px = 40./a; // X-Momentum / per nucleon!!!!!! Double_t py = 600./a; // Y-Momentum / per nucleon!!!!!! Double_t pz = 0.01/a; // Z-Momentum / per nucleon!!!!!! R3BIonGenerator* ionGen = new R3BIonGenerator(z,a,q,m,px,py,pz); ionGen->SetSpotRadius(1,1,0); // add the ion generator primGen->AddGenerator(ionGen); } if (fGenerator.CompareTo("ascii") == 0 ) { R3BAsciiGenerator* gen = new R3BAsciiGenerator((dir+"/input/"+InFile).Data()); primGen->AddGenerator(gen); } if (fGenerator.CompareTo("box") == 0 ) { // 2- Define the BOX generator Double_t pdgId=2212; // proton beam Double_t theta1= 25.; // polar angle distribution //Double_t theta2= 7.; Double_t theta2= 66.; // Double_t momentum=1.09008; // 500 MeV/c // Double_t momentum=0.4445834; // 100 MeV/c Double_t momentum1=TMath::Sqrt(energy1*energy1 + 2*energy1*0.938272046); Double_t momentum2=TMath::Sqrt(energy2*energy2 + 2*energy2*0.938272046); FairBoxGenerator* boxGen = new FairBoxGenerator(pdgId, 1); boxGen->SetThetaRange ( theta1, theta2); boxGen->SetPRange (momentum1,momentum2); boxGen->SetPhiRange (0,360.); //boxGen->SetXYZ(0.0,0.0,-1.5); boxGen->SetXYZ(0.0,0.0,0.0); boxGen->SetDebug(kFALSE); // add the box generator primGen->AddGenerator(boxGen); //primGen->SetTarget(0.25, 0.5); //primGen->SmearVertexZ(kTRUE); } if (fGenerator.CompareTo("gammas") == 0 ) { // 2- Define the CALIFA Test gamma generator //Double_t pdgId=22; // gamma emission Double_t pdgId=2212; // proton emission Double_t theta1= 10.; // polar angle distribution Double_t theta2= 40.; //Double_t theta2= 90.; //Double_t momentum=0.002; // 0.010 GeV/c = 10 MeV/c Double_t momentumI=0.002; // 0.010 GeV/c = 10 MeV/c Double_t momentumF=0.002; // 0.010 GeV/c = 10 MeV/c //Double_t momentumF=0.808065; // 0.808065 GeV/c (300MeV Kin Energy for protons) //Double_t momentumI=0.31016124; // 0.31016124 GeV/c (50MeV Kin Energy for protons) //Double_t momentum=0.4442972; // 0.4442972 GeV/c (100MeV Kin Energy for protons) //Double_t momentum=0.5509999; // 0.5509999 GeV/c (150MeV Kin Energy for protons) //Double_t momentumI=0.64405; // 0.64405 GeV/c (200MeV Kin Energy for protons) Int_t multiplicity = 1; R3BCALIFATestGenerator* gammasGen = new R3BCALIFATestGenerator(pdgId, multiplicity); gammasGen->SetThetaRange (theta1, theta2); gammasGen->SetCosTheta(); gammasGen->SetPRange(momentumI,momentumF); gammasGen->SetPhiRange(-180.,180.); //gammasGen->SetXYZ(0.0,0.0,-1.5); //gammasGen->SetXYZ(0.0,0.0,0); gammasGen->SetBoxXYZ(-0.1,0.1,-0.1,0.1,-0.1,0.1); //gammasGen->SetLorentzBoost(0.8197505718204776); //beta=0.81975 for 700 A MeV // add the gamma generator primGen->AddGenerator(gammasGen); } if (fGenerator.CompareTo("r3b") == 0 ) { R3BSpecificGenerator *pR3bGen = new R3BSpecificGenerator(); // R3bGen properties pR3bGen->SetBeamInteractionFlag("off"); pR3bGen->SetRndmFlag("off"); pR3bGen->SetRndmEneFlag("off"); pR3bGen->SetBoostFlag("off"); pR3bGen->SetReactionFlag("on"); pR3bGen->SetGammasFlag("off"); pR3bGen->SetDecaySchemeFlag("off"); pR3bGen->SetDissociationFlag("off"); pR3bGen->SetBackTrackingFlag("off"); pR3bGen->SetSimEmittanceFlag("off"); // R3bGen Parameters pR3bGen->SetBeamEnergy(1.); // Beam Energy in GeV pR3bGen->SetSigmaBeamEnergy(1.e-03); // Sigma(Ebeam) GeV pR3bGen->SetParticleDefinition(2212); // Use Particle Pdg Code pR3bGen->SetEnergyPrim(0.3); // Particle Energy in MeV Int_t fMultiplicity = 50; pR3bGen->SetNumberOfParticles(fMultiplicity); // Mult. // Reaction type // 1: "Elas" // 2: "iso" // 3: "Trans" pR3bGen->SetReactionType("Elas"); // Target type // 1: "LeadTarget" // 2: "Parafin0Deg" // 3: "Parafin45Deg" // 4: "LiH" pR3bGen->SetTargetType(Target.Data()); Double_t thickness = (0.11/2.)/10.; // cm pR3bGen->SetTargetHalfThicknessPara(thickness); // cm pR3bGen->SetTargetThicknessLiH(3.5); // cm pR3bGen->SetTargetRadius(1.); // cm pR3bGen->SetSigmaXInEmittance(1.); //cm pR3bGen->SetSigmaXPrimeInEmittance(0.0001); //cm // Dump the User settings pR3bGen->PrintParameters(); primGen->AddGenerator(pR3bGen); } if (fGenerator.CompareTo("p2p") == 0 ) { R3Bp2pGenerator* gen = new R3Bp2pGenerator(("/lustre/nyx/fairgsi/mwinkel/r3broot/input/p2p/build/" + InFile).Data()); primGen->AddGenerator(gen); #if 0 // Coincident gammas R3BGammaGenerator *gammaGen = new R3BGammaGenerator(); gammaGen->SetEnergyLevel(0, 0.); gammaGen->SetEnergyLevel(1, 3E-3); gammaGen->SetEnergyLevel(2, 4E-3); gammaGen->SetBranchingRatio(2, 1, 0.5); gammaGen->SetBranchingRatio(2, 0, 0.5); gammaGen->SetBranchingRatio(1, 0, 1.); gammaGen->SetInitialLevel(2); gammaGen->SetLorentzBoost(TVector3(0, 0, 0.777792)); primGen->AddGenerator(gammaGen); #endif } run->SetGenerator(primGen); //-------Set visualisation flag to true------------------------------------ run->SetStoreTraj(fVis); FairLogger::GetLogger()->SetLogVerbosityLevel("LOW"); // ----- Initialize CalifaHitFinder task (CrystalCal to Hit) ------------------------------------ if(fCalifaHitFinder) { R3BCalifaCrystalCal2Hit* califaHF = new R3BCalifaCrystalCal2Hit(); califaHF->SetClusteringAlgorithm(1,0); califaHF->SetDetectionThreshold(0.000050);//50 KeV califaHF->SetExperimentalResolution(6.); //percent @ 1 MeV //califaHF->SetComponentResolution(.25); //sigma = 0.5 MeV califaHF->SetPhoswichResolution(3.,5.); //percent @ 1 MeV for LaBr and LaCl califaHF->SelectGeometryVersion(17); califaHF->SetAngularWindow(0.25,0.25); //[0.25 around 14.3 degrees, 3.2 for the complete calorimeter] run->AddTask(califaHF); } // ----- Initialize StarTrackHitfinder task ------------------------------------ if(fStarTrackHitFinder) { R3BSTaRTraHitFinder* trackHF = new R3BSTaRTraHitFinder(); //trackHF->SetClusteringAlgorithm(1,0); trackHF->SetDetectionThreshold(0.000050); //50 KeV trackHF->SetExperimentalResolution(0.); //trackHF->SetAngularWindow(0.15,0.15); //[0.25 around 14.3 degrees, 3.2 for the complete calorimeter] run->AddTask(trackHF); } // ----- Initialize simulation run ------------------------------------ run->Init(); // ------ Increase nb of step for CALO Int_t nSteps = 150000; TVirtualMC::GetMC()->SetMaxNStep(nSteps); // ----- Runtime database --------------------------------------------- R3BFieldPar* fieldPar = (R3BFieldPar*) rtdb->getContainer("R3BFieldPar"); fieldPar->SetParameters(magField); fieldPar->setChanged(); Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(ParFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ----- Start run ---------------------------------------------------- if(nEvents > 0) { run->Run(nEvents); } // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << OutFile << endl; cout << "Parameter file is " << ParFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; // ------------------------------------------------------------------------ cout << " Test passed" << endl; cout << " All ok " << endl; }
void run_CbmIonGenerator(Int_t nEvents = 1) { // ======================================================================== // Adjust this part according to your requirements // Input file //TString inPath = "/d/cbm03/urqmd/auau/25gev/centr/"; //TString inFile = inPath + "urqmd.auau.25gev.centr.0000.ftn14"; // Output file TString outFile = Form("sts.mc.root",nEvents); // Parameter file TString parFile = Form("params.root",nEvents); // Cave geometry TString caveGeom = "cave.geo"; // Target geometry TString targetGeom = "target_au_250mu.geo"; // Beam pipe geometry TString pipeGeom = "pipe_standard.geo"; // Magnet geometry and field map TString magnetGeom = "passive/magnet_v09e.geo"; TString fieldMap = "field_v10e"; Double_t fieldZ = 50.; // z position of field centre Double_t fieldScale = 1.; // field scaling factor // MVD geometry TString mvdGeom = "mvd/mvd_v07a.geo"; // STS geometry TString stsGeom = "sts/sts_v11a.geo"; //STS geometry for the same z position of all sensors //TString stsGeom = "sts_same_z.geo"; targetGeom = ""; magnetGeom = ""; stsGeom = ""; mvdGeom = ""; // In general, the following parts need not be touched // ======================================================================== // ---- Debug option ------------------------------------------------- gDebug = 0; // ------------------------------------------------------------------------ // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ------------------------------------------------------------------------ // ---- Load libraries ------------------------------------------------- gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C"); basiclibs(); gSystem->Load("libGeoBase"); gSystem->Load("libParBase"); gSystem->Load("libBase"); gSystem->Load("libCbmBase"); gSystem->Load("libCbmData"); gSystem->Load("libField"); gSystem->Load("libGen"); gSystem->Load("libPassive"); gSystem->Load("libMvd"); gSystem->Load("libSts"); gSystem->Load("libCbmGenerators"); // for CbmIonGenerator // ------------------------------------------------------------------------ // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName("TGeant3"); // Transport engine run->SetOutputFile(outFile); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // ------------------------------------------------------------------------ // ----- Create media ------------------------------------------------- run->SetMaterials("media.geo"); // Materials // ------------------------------------------------------------------------ // ----- Create geometry ---------------------------------------------- FairModule* cave= new CbmCave("CAVE"); cave->SetGeometryFileName(caveGeom); run->AddModule(cave); FairModule* pipe= new CbmPipe("PIPE"); pipe->SetGeometryFileName(pipeGeom); run->AddModule(pipe); if( targetGeom != "") { FairModule* target= new CbmTarget("Target"); target->SetGeometryFileName(targetGeom); run->AddModule(target); } if( magnetGeom != "") { FairModule* magnet= new CbmMagnet("MAGNET"); magnet->SetGeometryFileName(magnetGeom); run->AddModule(magnet); } if( mvdGeom != ""){ FairDetector* mvd= new CbmMvd("MVD", kTRUE); mvd->SetGeometryFileName(mvdGeom); run->AddModule(mvd); } if( stsGeom != "") { FairDetector* sts= new CbmSts("STS", kTRUE); sts->SetGeometryFileName(stsGeom); run->AddModule(sts); } // ------------------------------------------------------------------------ // ----- Create magnetic field ---------------------------------------- if(magnetGeom!="") { CbmFieldMap* magField = new CbmFieldMapSym2(fieldMap); magField->SetPosition(0., 0., fieldZ); magField->SetScale(fieldScale); run->SetField(magField); } // ------------------------------------------------------------------------ // ----- Create PrimaryGenerator -------------------------------------- FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); //FairUrqmdGenerator* urqmdGen = new FairUrqmdGenerator(inFile); //primGen->AddGenerator(urqmdGen); // CbmIonGenerator - check in Load libraries: gSystem->Load("libCbmGenerators"); Int_t nions=10; // number of ions/event cout<<"@@@@@> CbmIonGenerator is ON with "<<nions<<" ion(s)/event !!!"<<endl; Int_t z=79, a=197, q=79; // Au-ion Double_t p=8.; // in AGeV/c Double_t vz=-0.0126; // in cm - z-pos. of vertex Double_t meanX=0.3; // in cm - spatial distr. (XOY) Double_t meanY=-0.2; // in cm Double_t sigmaX = 0.078; // in cm - spatial distr. (XOY) Double_t sigmaY = 0.032; // in cm Double_t sigmatX = 0.00117885; // in rad (Px/P) - angular distr. (mean=0) Double_t sigmatY = 0.00094955; // in rad (Py/P) // Parameters of the trapezoid are set with respect to mean of Gaussian, NOT necesseraly in absolute coordinates. // x1 < x2 < 0 < x3 < x4 Double_t x1=-0.10452, x2=-0.06942, x3=0.06942, x4=0.10452; // in cm - trapezoid distr. Double_t y1=-0.04448, y2=-0.02688, y3=0.02688, y4=0.04448; // in cm Double_t tX1=-0.00157966, tX2=-0.001049177, tX3=0.001049177, tX4=0.00157966; // in rad Double_t tY1=-0.00131987, tY2=-0.000797622, tY3=0.000797622, tY4=0.00131987; // in rad // CbmIonGenerator *IonGen = new CbmIonGenerator(z, a, q, nions, p, sigmaX, sigmaY, sigmatX, sigmatY); // CbmIonGenerator *IonGen = new CbmIonGenerator(z, a, q, nions, p, sigmaX, sigmaY, sigmatX, sigmatY, meanX, meanY, vz); CbmIonGenerator *IonGen = new CbmIonGenerator(z, a, q, nions, p, sigmaX, sigmaY, sigmatX, sigmatY, meanX, meanY, vz, x1, x2, x3, x4, y1, y2, y3, y4, tX1, tX2, tX3, tX4, tY1, tY2, tY3, tY4); primGen->AddGenerator(IonGen); run->SetGenerator(primGen); // ------------------------------------------------------------------------ // run->SetStoreTraj(kTRUE); // ----- Initialize simulation run ------------------------------------ run->Init(); // ------------------------------------------------------------------------ // ----- Runtime database --------------------------------------------- if(magnetGeom!="") { CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar"); fieldPar->SetParameters(magField); fieldPar->setChanged(); fieldPar->setInputVersion(run->GetRunId(),1); } Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ------------------------------------------------------------------------ // ----- Start run ---------------------------------------------------- run->Run(nEvents); // ------------------------------------------------------------------------ //run->CreateGeometryFile("data/geofile_full.root"); // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << outFile << endl; cout << "Parameter file is " << parFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; // ------------------------------------------------------------------------ cout << " Test passed" << endl; cout << " All ok " << endl; exit(0); }
void simall(Int_t nEvents = 1, TObjArray& fDetList, Bool_t fVis=kFALSE, TString fMC="TGeant3", TString fGenerator="mygenerator", Bool_t fUserPList= kFALSE ) { TString dir = getenv("VMCWORKDIR"); TString simdir = dir + "/macros"; TString sim_geomdir = dir + "/geometry"; gSystem->Setenv("GEOMPATH",sim_geomdir.Data()); TString sim_confdir = dir + "gconfig"; gSystem->Setenv("CONFIG_DIR",sim_confdir.Data()); // Output files TString OutFile = "simout.root"; TString ParFile = "simpar.root"; // In general, the following parts need not be touched // ======================================================================== // ---- Debug option ------------------------------------------------- gDebug = 0; // ------------------------------------------------------------------------ // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ------------------------------------------------------------------------ // ---- Load libraries ------------------------------------------------- gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C"); basiclibs(); gSystem->Load("libGenVector"); gSystem->Load("libGeoBase"); gSystem->Load("libFairDB"); gSystem->Load("libParBase"); gSystem->Load("libBase"); gSystem->Load("libMCStack"); gSystem->Load("libField"); gSystem->Load("libGen"); //---- Load specific libraries --------------------------------------- gSystem->Load("libEnsarbase"); gSystem->Load("libEnsarGen"); gSystem->Load("libEnsarData"); gSystem->Load("libEnsarMyDet"); // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName(fMC.Data()); // Transport engine run->SetOutputFile(OutFile.Data()); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // R3B Special Physics List in G4 case if ( (fUserPList == kTRUE ) && (fMC.CompareTo("TGeant4") == 0) ){ run->SetUserConfig("g4Config.C"); run->SetUserCuts("SetCuts.C"); } // ----- Create media ------------------------------------------------- //run->SetMaterials("media_r3b.geo"); // Materials // Magnetic field map type // Int_t fFieldMap = 0; // Global Transformations //- Two ways for a Volume Rotation are supported //-- 1) Global Rotation (Euler Angles definition) //-- This represent the composition of : first a rotation about Z axis with //-- angle phi, then a rotation with theta about the rotated X axis, and //-- finally a rotation with psi about the new Z axis. Double_t phi,theta,psi; //-- 2) Rotation in Ref. Frame of the Volume //-- Rotation is Using Local Ref. Frame axis angles Double_t thetaX,thetaY,thetaZ; //- Global Translation Lab. frame. Double_t tx,ty,tz; // ----- Create geometry -------------------------------------------- if (fDetList.FindObject("MYDET") ) { //My Detector definition EnsarDetector* mydet = new EnsarMyDet("MyDet", kTRUE); // Global position of the Module phi = 0.0; // (deg) theta = 0.0; // (deg) psi = 0.0; // (deg) // Rotation in Ref. Frame. thetaX = 0.0; // (deg) thetaY = 0.0; // (deg) thetaZ = 0.0; // (deg) // Global translation in Lab tx = 0.0; // (cm) ty = 0.0; // (cm) tz = 0.0; // (cm) mydet->SetRotAnglesXYZ(thetaX,thetaY,thetaZ); mydet->SetTranslation(tx,ty,tz); run->AddModule(mydet); } // ----- Create PrimaryGenerator -------------------------------------- // 1 - Create the Main API class for the Generator FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); if (fGenerator.CompareTo("mygenerator") == 0 ) { // 2- Define the generator Double_t pdgId=211; // pion beam Double_t theta1= 0.; // polar angle distribution Double_t theta2= 7.; Double_t momentum=.8; // 10 GeV/c Int_t multiplicity = 50; // multiplicity (nb particles per event) FairBoxGenerator* boxGen = new FairBoxGenerator(pdgId,multiplicity); boxGen->SetThetaRange ( theta1, theta2); boxGen->SetPRange (momentum,momentum*2.); boxGen->SetPhiRange (0.,360.); boxGen->SetXYZ(0.0,0.0,-1.5); // add the box generator primGen->AddGenerator(boxGen); } run->SetGenerator(primGen); //-------Set visualisation flag to true------------------------------------ if (fVis==kTRUE){ run->SetStoreTraj(kTRUE); }else{ run->SetStoreTraj(kFALSE); } // ----- Initialize simulation run ------------------------------------ run->Init(); // ------ Increase nb of step Int_t nSteps = -15000; gMC->SetMaxNStep(nSteps); // ----- Runtime database --------------------------------------------- Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(ParFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ----- Start run ---------------------------------------------------- if (nEvents>0) run->Run(nEvents); // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << OutFile << endl; cout << "Parameter file is " << ParFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; // ------------------------------------------------------------------------ cout << " Test passed" << endl; cout << " All ok " << endl; }
void makeDummy(const Int_t nEvents = 10) { gRandom -> SetSeed(time(0)); //TString dir = gSystem->Getenv("SPIRITDIR"); //TString geomdir = dir + "/geometry"; //gSystem->Setenv("GEOMPATH", geomdir.Data()); FairLogger *logger = FairLogger::GetLogger(); logger->SetLogToScreen(kTRUE); logger->SetLogVerbosityLevel("MEDIUM"); TString outFile = "mc.dummy.root"; TString parFile = "param.dummy.root"; // ----- Create simulation run ---------------------------------------- // FairRunSim* run = new FairRunSim(); run->SetName("TGeant4"); // Transport engine run->SetOutputFile(outFile); // Output file run->SetWriteRunInfoFile(kFALSE); FairRuntimeDb* rtdb = run->GetRuntimeDb(); ATVertexPropagator* vertex_prop = new ATVertexPropagator(); // ------------------------------------------------------------------------ // ----- Create geometry ---------------------------------------------- /*FairModule* cave= new FairCave("CAVE"); cave->SetGeometryFileName("cave_vacuum.geo"); run->AddModule(cave); FairModule* target= new FairTarget("SnTarget"); target->SetGeometryFileName("target.geo"); run->AddModule(target); FairDetector* spirit = new STDetector("STDetector", kTRUE); spirit->SetGeometryFileName("spirit_v03.1.root"); run->AddModule(spirit);*/ FairModule* cave= new AtCave("CAVE"); cave->SetGeometryFileName("cave.geo"); run->AddModule(cave); FairModule* magnet = new AtMagnet("Magnet"); run->AddModule(magnet); FairModule* pipe = new AtPipe("Pipe"); run->AddModule(pipe); FairDetector* ATTPC = new AtTpc("ATTPC", kTRUE); ATTPC->SetGeometryFileName("ATTPC_v1.1.root"); //ATTPC->SetModifyGeometry(kTRUE); run->AddModule(ATTPC); // ------------------------------------------------------------------------ run->SetMaterials("media.geo"); // ----- Create PrimaryGenerator -------------------------------------- FairPrimaryGenerator *primGen = new FairPrimaryGenerator(); FairParticleGenerator *particleGen = new FairParticleGenerator(2112, 1, 0, 0, 0, 0, 0, 0); primGen->AddGenerator(particleGen); run->SetGenerator(primGen); /* Int_t dnum=7; const int gennum=pid[dnum].size(); cout << gennum << endl; FairParticleGenerator *fIongen[gennum]; for (Int_t i=0; i<gennum; i++) { fIongen[i] = new FairParticleGenerator(pid[dnum][i],1,pxl[dnum][i],pyl[dnum][i],pzl[dnum][i],0.0,-21.33,-3.52); //cout << pid[dnum][i] << "\t" << pxl[dnum][i] << "\t" << pyl[dnum][i] << "\t" << pzl[dnum][i] << "\t" << kinl[dnum][i] << endl; primGen->AddGenerator(fIongen[i]); } //primGen->AddTrack(pdg,pionpC[0][i],pionpC[1][i],pionpC[2][i],pionrC[0][i]*1.0E-13,pionrC[1][i]*1.0E-13-21.33,pionrC[2][i]*1.0E-13-3.52); //fIongen[i] = new FairParticleGenerator(pdg,1,pionpC[0][i],pionpC[1][i],pionpC[2][i],pionrC[0][i]*1.0E-13,pionrC[1][i]*1.0E-13-21.33,pionrC[2][i]*1.0E-13-3.52); //fIongen[i] = new FairParticleGenerator(pdg,1,px,py,pz,0.0,-21.33,-3.52); //primGen->AddGenerator(fIongen[i]); //primGen->AddTrack(pdg,pionpC[0][i],pionpC[1][i],pionpC[2][i],pionrC[0][i]*1.0E-13,pionrC[1][i]*1.0E-13-21.33,pionrC[2][i]*1.0E-13-3.52); //} //} // if (partt==0) FairBoxGenerator* boxGen1 = new FairBoxGenerator(2212, 1); // if (partt==1) FairBoxGenerator* boxGen1 = new FairBoxGenerator(1000010020, 1); // if (partt==2) FairBoxGenerator* boxGen1 = new FairBoxGenerator(1000010030, 1); // if (partt==3) FairBoxGenerator* boxGen1 = new FairBoxGenerator(1000020030, 1); // if (partt==4) FairBoxGenerator* boxGen1 = new FairBoxGenerator(1000020040, 1); // if (partt==5) FairBoxGenerator* boxGen1 = new FairBoxGenerator(211, 1); // if (partt==6) FairBoxGenerator* boxGen1 = new FairBoxGenerator(-211, 1); // if (partt==7) FairBoxGenerator* boxGen1 = new FairBoxGenerator(11, 1); // if (partt==8) FairBoxGenerator* boxGen1 = new FairBoxGenerator(-11, 1); // //FairBoxGenerator* boxGen1 = new FairBoxGenerator(1000020040, 1); // boxGen1->SetPRange(0.25,0.5); //GeV/c ?? // boxGen1->SetPhiRange(0.,360.); //degrees // boxGen1->SetThetaRange(0.,90.); //degrees // boxGen1->SetXYZ(0.,-21.33, -3.52); // cm // primGen->AddGenerator(boxGen1); // ------------------------------------------------------------------------ run->SetStoreTraj(kTRUE); */ // ----- Run initialisation ------------------------------------------- run->Init(); // ------------------------------------------------------------------------ // ----- Runtime database --------------------------------------------- Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); // ------------------------------------------------------------------------ // ----- Start run ---------------------------------------------------- run->Run(nEvents); // ----- Finish ------------------------------------------------------- }
void ana_complete(int nevts=0) { TDatabasePDG::Instance()->AddParticle("pbarpSystem","pbarpSystem",1.9,kFALSE,0.1,0,"",88888); TStopwatch fTimer; // *** some variables int i=0,j=0, k=0, l=0; gStyle->SetOptFit(1011); // *** the output file for FairRunAna TString OutFile="output.root"; // *** the files coming from the simulation TString inPidFile = "psi2s_jpsi2pi_jpsi_mumu_pid.root"; // this file contains the PndPidCandidates and McTruth TString inParFile = "psi2s_jpsi2pi_jpsi_mumu_par.root"; // *** PID table with selection thresholds; can be modified by the user TString pidParFile = TString(gSystem->Getenv("VMCWORKDIR"))+"/macro/params/all_day1.par"; // *** initialization FairLogger::GetLogger()->SetLogToFile(kFALSE); FairRunAna* fRun = new FairRunAna(); FairRuntimeDb* rtdb = fRun->GetRuntimeDb(); fRun->SetInputFile(inPidFile); // *** setup parameter database FairParRootFileIo* parIO = new FairParRootFileIo(); parIO->open(inParFile); FairParAsciiFileIo* parIOPid = new FairParAsciiFileIo(); parIOPid->open(pidParFile.Data(),"in"); rtdb->setFirstInput(parIO); rtdb->setSecondInput(parIOPid); rtdb->setOutput(parIO); fRun->SetOutputFile(OutFile); fRun->Init(); // *** create an output file for all histograms TFile *out = TFile::Open("output_ana.root","RECREATE"); // *** create some histograms TH1F *hmomtrk = new TH1F("hmomtrk","track momentum (all)",200,0,5); TH1F *hthttrk = new TH1F("hthttrk","track theta (all)",200,0,3.1415); TH1F *hjpsim_all = new TH1F("hjpsim_all","J/#psi mass (all)",200,0,4.5); TH1F *hpsim_all = new TH1F("hpsim_all","#psi(2S) mass (all)",200,0,5); TH1F *hjpsim_lpid = new TH1F("hjpsim_lpid","J/#psi mass (loose pid)",200,0,4.5); TH1F *hpsim_lpid = new TH1F("hpsim_lpid","#psi(2S) mass (loose pid)",200,0,5); TH1F *hjpsim_tpid = new TH1F("hjpsim_tpid","J/#psi mass (tight pid)",200,0,4.5); TH1F *hpsim_tpid = new TH1F("hpsim_tpid","#psi(2S) mass (tight pid)",200,0,5); TH1F *hjpsim_trpid = new TH1F("hjpsim_trpid","J/#psi mass (true pid)",200,0,4.5); TH1F *hpsim_trpid = new TH1F("hpsim_trpid","#psi(2S) mass (true pid)",200,0,5); TH1F *hjpsim_ftm = new TH1F("hjpsim_ftm","J/#psi mass (full truth match)",200,0,4.5); TH1F *hpsim_ftm = new TH1F("hpsim_ftm","#psi(2S) mass (full truth match)",200,0,5); TH1F *hjpsim_nm = new TH1F("hjpsim_nm","J/#psi mass (no truth match)",200,0,4.5); TH1F *hpsim_nm = new TH1F("hpsim_nm","#psi(2S) mass (no truth match)",200,0,5); TH1F *hjpsim_diff = new TH1F("hjpsim_diff","J/#psi mass diff to truth",100,-2,2); TH1F *hpsim_diff = new TH1F("hpsim_diff","#psi(2S) mass diff to truth",100,-2,2); TH1F *hjpsim_vf = new TH1F("hjpsim_vf","J/#psi mass (vertex fit)",200,0,4.5); TH1F *hjpsim_4cf = new TH1F("hjpsim_4cf","J/#psi mass (4C fit)",200,0,4.5); TH1F *hjpsim_mcf = new TH1F("hjpsim_mcf","J/#psi mass (mass constraint fit)",200,0,4.5); TH1F *hjpsi_chi2_vf = new TH1F("hjpsi_chi2_vf", "J/#psi: #chi^{2} vertex fit",100,0,10); TH1F *hpsi_chi2_4c = new TH1F("hpsi_chi2_4c", "#psi(2S): #chi^{2} 4C fit",100,0,250); TH1F *hjpsi_chi2_mf = new TH1F("hjpsi_chi2_mf", "J/#psi: #chi^{2} mass fit",100,0,10); TH1F *hjpsi_prob_vf = new TH1F("hjpsi_prob_vf", "J/#psi: Prob vertex fit",100,0,1); TH1F *hpsi_prob_4c = new TH1F("hpsi_prob_4c", "#psi(2S): Prob 4C fit",100,0,1); TH1F *hjpsi_prob_mf = new TH1F("hjpsi_prob_mf", "J/#psi: Prob mass fit",100,0,1); TH2F *hvpos = new TH2F("hvpos","(x,y) projection of fitted decay vertex",100,-2,2,100,-2,2); // // Now the analysis stuff comes... // // *** the data reader object PndAnalysis* theAnalysis = new PndAnalysis(); if (nevts==0) nevts= theAnalysis->GetEntries(); // *** RhoCandLists for the analysis RhoCandList chrg, muplus, muminus, piplus, piminus, jpsi, psi2s; // *** Mass selector for the jpsi cands double m0_jpsi = TDatabasePDG::Instance()->GetParticle("J/psi")->Mass(); // Get nominal PDG mass of the J/psi RhoMassParticleSelector *jpsiMassSel=new RhoMassParticleSelector("jpsi",m0_jpsi,1.0); // *** the lorentz vector of the initial psi(2S) TLorentzVector ini(0, 0, 6.231552, 7.240065); // *** // the event loop // *** int cntdbltrk=0, cntdblmc=0, cntdblboth=0, cnttrk=0, cnt_dbl_jpsi=0, cnt_dbl_psip=0; while (theAnalysis->GetEvent() && i++<nevts) { if ((i%100)==0) cout<<"evt " << i << endl; // *** Select with no PID info ('All'); type and mass are set theAnalysis->FillList(chrg, "Charged"); theAnalysis->FillList(muplus, "MuonAllPlus"); theAnalysis->FillList(muminus, "MuonAllMinus"); theAnalysis->FillList(piplus, "PionAllPlus"); theAnalysis->FillList(piminus, "PionAllMinus"); // *** momentum and theta histograms for (j=0;j<muplus.GetLength();++j) { hmomtrk->Fill(muplus[j]->P()); hthttrk->Fill(muplus[j]->P4().Theta()); } for (j=0;j<muminus.GetLength();++j) { hmomtrk->Fill(muminus[j]->P()); hthttrk->Fill(muminus[j]->P4().Theta()); } cnttrk += chrg.GetLength(); int n1, n2, n3; countDoubles(chrg,n1,n2,n3); cntdbltrk += n1; cntdblmc += n2; cntdblboth += n3; // *** combinatorics for J/psi -> mu+ mu- jpsi.Combine(muplus, muminus); // *** // *** do the TRUTH MATCH for jpsi // *** jpsi.SetType(443); int nm = 0; for (j=0;j<jpsi.GetLength();++j) { hjpsim_all->Fill( jpsi[j]->M() ); if (theAnalysis->McTruthMatch(jpsi[j])) { nm++; hjpsim_ftm->Fill( jpsi[j]->M() ); hjpsim_diff->Fill( jpsi[j]->GetMcTruth()->M() - jpsi[j]->M() ); } else hjpsim_nm->Fill( jpsi[j]->M() ); } if (nm>1) cnt_dbl_jpsi++; // *** // *** do VERTEX FIT (J/psi) // *** for (j=0;j<jpsi.GetLength();++j) { PndKinVtxFitter vtxfitter(jpsi[j]); // instantiate a vertex fitter vtxfitter.Fit(); double chi2_vtx = vtxfitter.GetChi2(); // access chi2 of fit double prob_vtx = vtxfitter.GetProb(); // access probability of fit hjpsi_chi2_vf->Fill(chi2_vtx); hjpsi_prob_vf->Fill(prob_vtx); if ( prob_vtx > 0.01 ) // when good enough, fill some histos { RhoCandidate *jfit = jpsi[j]->GetFit(); // access the fitted cand TVector3 jVtx=jfit->Pos(); // and the decay vertex position hjpsim_vf->Fill(jfit->M()); hvpos->Fill(jVtx.X(),jVtx.Y()); } } // *** some rough mass selection jpsi.Select(jpsiMassSel); // *** combinatorics for psi(2S) -> J/psi pi+ pi- psi2s.Combine(jpsi, piplus, piminus); // *** // *** do the TRUTH MATCH for psi(2S) // *** psi2s.SetType(88888); nm = 0; for (j=0;j<psi2s.GetLength();++j) { hpsim_all->Fill( psi2s[j]->M() ); if (theAnalysis->McTruthMatch(psi2s[j])) { nm++; hpsim_ftm->Fill( psi2s[j]->M() ); hpsim_diff->Fill( psi2s[j]->GetMcTruth()->M() - psi2s[j]->M() ); } else hpsim_nm->Fill( psi2s[j]->M() ); } if (nm>1) cnt_dbl_psip++; // *** // *** do 4C FIT (initial psi(2S) system) // *** for (j=0;j<psi2s.GetLength();++j) { PndKinFitter fitter(psi2s[j]); // instantiate the kin fitter in psi(2S) fitter.Add4MomConstraint(ini); // set 4 constraint fitter.Fit(); // do fit double chi2_4c = fitter.GetChi2(); // get chi2 of fit double prob_4c = fitter.GetProb(); // access probability of fit hpsi_chi2_4c->Fill(chi2_4c); hpsi_prob_4c->Fill(prob_4c); if ( prob_4c > 0.01 ) // when good enough, fill some histo { RhoCandidate *jfit = psi2s[j]->Daughter(0)->GetFit(); // get fitted J/psi hjpsim_4cf->Fill(jfit->M()); } } // *** // *** do MASS CONSTRAINT FIT (J/psi) // *** for (j=0;j<jpsi.GetLength();++j) { PndKinFitter mfitter(jpsi[j]); // instantiate the PndKinFitter in psi(2S) mfitter.AddMassConstraint(m0_jpsi); // add the mass constraint mfitter.Fit(); // do fit double chi2_m = mfitter.GetChi2(); // get chi2 of fit double prob_m = mfitter.GetProb(); // access probability of fit hjpsi_chi2_mf->Fill(chi2_m); hjpsi_prob_mf->Fill(prob_m); if ( prob_m > 0.01 ) // when good enough, fill some histo { RhoCandidate *jfit = jpsi[j]->GetFit(); // access the fitted cand hjpsim_mcf->Fill(jfit->M()); } } // *** // *** TRUE PID combinatorics // *** // *** do MC truth match for PID type SelectTruePid(theAnalysis, muplus); SelectTruePid(theAnalysis, muminus); SelectTruePid(theAnalysis, piplus); SelectTruePid(theAnalysis, piminus); // *** all combinatorics again with true PID jpsi.Combine(muplus, muminus); for (j=0;j<jpsi.GetLength();++j) hjpsim_trpid->Fill( jpsi[j]->M() ); jpsi.Select(jpsiMassSel); psi2s.Combine(jpsi, piplus, piminus); for (j=0;j<psi2s.GetLength();++j) hpsim_trpid->Fill( psi2s[j]->M() ); // *** // *** LOOSE PID combinatorics // *** // *** and again with PidAlgoMvd;PidAlgoStt;PidAlgoDrc and loose selection theAnalysis->FillList(muplus, "MuonLoosePlus", "PidAlgoMvd;PidAlgoStt;PidAlgoDrc;PidAlgoMdtHardCuts"); theAnalysis->FillList(muminus, "MuonLooseMinus", "PidAlgoMvd;PidAlgoStt;PidAlgoDrc;PidAlgoMdtHardCuts"); theAnalysis->FillList(piplus, "PionLoosePlus", "PidAlgoMvd;PidAlgoStt;PidAlgoDrc"); theAnalysis->FillList(piminus, "PionLooseMinus", "PidAlgoMvd;PidAlgoStt;PidAlgoDrc"); jpsi.Combine(muplus, muminus); for (j=0;j<jpsi.GetLength();++j) hjpsim_lpid->Fill( jpsi[j]->M() ); jpsi.Select(jpsiMassSel); psi2s.Combine(jpsi, piplus, piminus); for (j=0;j<psi2s.GetLength();++j) hpsim_lpid->Fill( psi2s[j]->M() ); // *** // *** TIGHT PID combinatorics // *** // *** and again with PidAlgoMvd;PidAlgoStt and tight selection theAnalysis->FillList(muplus, "MuonTightPlus", "PidAlgoMdtHardCuts"); theAnalysis->FillList(muminus, "MuonTightMinus", "PidAlgoMdtHardCuts"); theAnalysis->FillList(piplus, "PionLoosePlus", "PidAlgoMvd;PidAlgoStt;PidAlgoDrc"); theAnalysis->FillList(piminus, "PionLooseMinus", "PidAlgoMvd;PidAlgoStt;PidAlgoDrc"); jpsi.Combine(muplus, muminus); for (j=0;j<jpsi.GetLength();++j) hjpsim_tpid->Fill( jpsi[j]->M() ); jpsi.Select(jpsiMassSel); psi2s.Combine(jpsi, piplus, piminus); for (j=0;j<psi2s.GetLength();++j) hpsim_tpid->Fill( psi2s[j]->M() ); } // *** write out all the histos out->cd(); hmomtrk->Write(); hthttrk->Write(); hjpsim_all->Write(); hpsim_all->Write(); hjpsim_lpid->Write(); hpsim_lpid->Write(); hjpsim_tpid->Write(); hpsim_tpid->Write(); hjpsim_trpid->Write(); hpsim_trpid->Write(); hjpsim_ftm->Write(); hpsim_ftm->Write(); hjpsim_nm->Write(); hpsim_nm->Write(); hpsim_diff->Write(); hjpsim_diff->Write(); hjpsim_vf->Write(); hjpsim_4cf->Write(); hjpsim_mcf->Write(); hjpsi_chi2_vf->Write(); hpsi_chi2_4c->Write(); hjpsi_chi2_mf->Write(); hjpsi_prob_vf->Write(); hpsi_prob_4c->Write(); hjpsi_prob_mf->Write(); hvpos->Write(); out->Save(); // Extract the maximal used memory an add is as Dart measurement // This line is filtered by CTest and the value send to CDash FairSystemInfo sysInfo; Float_t maxMemory=sysInfo.GetMaxMemory(); cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">"; cout << maxMemory; cout << "</DartMeasurement>" << endl; fTimer.Stop(); Double_t rtime = fTimer.RealTime(); Double_t ctime = fTimer.CpuTime(); Float_t cpuUsage=ctime/rtime; cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">"; cout << cpuUsage; cout << "</DartMeasurement>" << endl; cout << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl; cout << "CPU usage " << cpuUsage*100. << "%" << endl; cout << "Max Memory " << maxMemory << " MB" << endl; cout << "Macro finished successfully." << endl; exit(0); }
/******************************************************************************** * Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH * * * * This software is distributed under the terms of the * * GNU Lesser General Public Licence version 3 (LGPL) version 3, * * copied verbatim in the file "LICENSE" * ********************************************************************************/ void run_tutorial1(Int_t nEvents = 10, TString mcEngine = "TGeant3") { TString dir = getenv("VMCWORKDIR"); TString tutdir = dir + "/Tutorial1"; TString tut_geomdir = dir + "/geometry"; gSystem->Setenv("GEOMPATH",tut_geomdir.Data()); TString tut_configdir = dir + "/gconfig"; gSystem->Setenv("CONFIG_DIR",tut_configdir.Data()); TString partName[] = {"pions","eplus","proton"}; Int_t partPdgC[] = { 211, 11, 2212}; Int_t chosenPart = 0; Double_t momentum = 2.; Double_t theta = 0.; TString outDir = "./"; // Output file name TString outFile = Form("%s/tutorial1_%s_%s.mc_p%1.3f_t%1.0f_n%d.root", outDir.Data(), mcEngine.Data(), partName[chosenPart].Data(), momentum, theta, nEvents); // Parameter file name TString parFile = Form("%s/tutorial1_%s_%s.params_p%1.3f_t%1.0f_n%d.root", outDir.Data(), mcEngine.Data(), partName[chosenPart].Data(), momentum, theta, nEvents); // In general, the following parts need not be touched // ======================================================================== // ---- Debug option ------------------------------------------------- gDebug = 0; // ------------------------------------------------------------------------ // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ------------------------------------------------------------------------ // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName(mcEngine); // Transport engine run->SetOutputFile(outFile); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // ------------------------------------------------------------------------ // ----- Create media ------------------------------------------------- run->SetMaterials("media.geo"); // Materials // ------------------------------------------------------------------------ // ----- Create geometry ---------------------------------------------- FairModule* cave= new FairCave("CAVE"); cave->SetGeometryFileName("cave_vacuum.geo"); run->AddModule(cave); FairDetector* tutdet = new FairTutorialDet1("TUTDET", kTRUE); tutdet->SetGeometryFileName("double_sector.geo"); run->AddModule(tutdet); // ------------------------------------------------------------------------ // ----- Create PrimaryGenerator -------------------------------------- FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); FairBoxGenerator* boxGen = new FairBoxGenerator(partPdgC[chosenPart], 1); boxGen->SetThetaRange ( theta, theta+0.01); boxGen->SetPRange (momentum,momentum+0.01); boxGen->SetPhiRange (0.,360.); boxGen->SetDebug(kTRUE); primGen->AddGenerator(boxGen); run->SetGenerator(primGen); // ------------------------------------------------------------------------ // ----- Initialize simulation run ------------------------------------ run->Init(); // ------------------------------------------------------------------------ // ----- Runtime database --------------------------------------------- Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ------------------------------------------------------------------------ // ----- Start run ---------------------------------------------------- run->Run(nEvents); run->CreateGeometryFile("geofile_full.root"); // ------------------------------------------------------------------------ // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << outFile << endl; cout << "Parameter file is " << parFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; // ------------------------------------------------------------------------ }
void run_rad(Int_t nEvents = 100, TString mcEngine="TGeant3") { TString dir = gSystem->Getenv("VMCWORKDIR"); TString tutdir = dir + "/rutherford/macros"; TString tut_geomdir = dir + "/geometry"; gSystem->Setenv("GEOMPATH",tut_geomdir.Data()); TString tut_configdir = dir + "/gconfig"; gSystem->Setenv("CONFIG_DIR",tut_configdir.Data()); TString outDir = "data"; TString outFile = outDir + "/test1_"; outFile = outFile + mcEngine + ".mc.root"; TString parFile = outDir + "/params1_"; parFile = parFile + mcEngine + ".root"; // In general, the following parts need not be touched // ======================================================================== // ---- Debug option ------------------------------------------------- gDebug = 0; // ------------------------------------------------------------------------ // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ------------------------------------------------------------------------ FairLogger *logger = FairLogger::GetLogger(); // define log file name logger->SetLogFileName("MyLog.log"); // log to screen and to file logger->SetLogToScreen(kTRUE); logger->SetLogToFile(kTRUE); // Print very accurate output. Levels are LOW, MEDIUM and HIGH logger->SetLogVerbosityLevel("HIGH"); // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName(mcEngine); // Transport engine run->SetOutputFile(outFile); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // ------------------------------------------------------------------------ // ----- Create media ------------------------------------------------- run->SetMaterials("media.geo"); // Materials // ------------------------------------------------------------------------ //----Start the radiation length manager ---------------------------------- run->SetRadLenRegister(kTRUE); // ----- Create geometry ---------------------------------------------- FairModule* cave= new FairCave("CAVE"); cave->SetGeometryFileName("cave_vacuum.geo"); run->AddModule(cave); FairModule* target= new FairTarget("Target"); target->SetGeometryFileName("target_rutherford.geo"); run->AddModule(target); FairDetector* rutherford = new FairRutherford("RutherfordDetector", kFALSE); rutherford->SetGeometryFileName("rutherford.geo"); run->AddModule(rutherford); // ------------------------------------------------------------------------ // ----- Create PrimaryGenerator -------------------------------------- FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); run->SetGenerator(primGen); FairBoxGenerator* boxGen1 = new FairBoxGenerator(0, 1); boxGen1->SetPRange(.005,.005); boxGen1->SetPhiRange(0.,0.); boxGen1->SetThetaRange(-90.,90.); boxGen1->SetXYZ(0.,0.,-3.); primGen->AddGenerator(boxGen1); // ------------------------------------------------------------------------ run->SetStoreTraj(kTRUE); // ----- Run initialisation ------------------------------------------- run->Init(); // ------------------------------------------------------------------------ // Set cuts for storing the trajectories. // Switch this on only if trajectories are stored. // Choose this cuts according to your needs, but be aware // that the file size of the output file depends on these cuts FairTrajFilter* trajFilter = FairTrajFilter::Instance(); // trajFilter->SetStepSizeCut(0.01); // 1 cm // trajFilter->SetVertexCut(-2000., -2000., 4., 2000., 2000., 100.); // trajFilter->SetMomentumCutP(10e-3); // p_lab > 10 MeV // trajFilter->SetEnergyCut(0., 1.02); // 0 < Etot < 1.04 GeV trajFilter->SetStorePrimaries(kTRUE); trajFilter->SetStoreSecondaries(kTRUE); // ------------------------------------------------------------------------ // ----- Runtime database --------------------------------------------- Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ------------------------------------------------------------------------ // ----- Start run ---------------------------------------------------- run->Run(nEvents); // ------------------------------------------------------------------------ run->CreateGeometryFile("data/geofile_full.root"); // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << outFile << endl; cout << "Parameter file is " << parFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; // ------------------------------------------------------------------------ }
void run_sim(Int_t gen=1, Int_t nEvents = 1, Int_t fileNum = 100) { TString rootVersion = "feb16"; const char* setup = "sis100_electron"; TString sfileNum = ""; sfileNum += fileNum; // ======================================================================== // Adjust this part according to your requirements // ----- Paths and file names -------------------------------------------- TString inDir = "/hera/cbm/users/klochkov/cbm/data/input/au10au/shield/test_10k/"; TString inFile = inDir + "au10au_" + sfileNum + ".root"; TString outDir = "/hera/cbm/users/klochkov/cbm/data/au10au_10k_test_1/"; TString outFile = outDir + "sim/mc_" + sfileNum + ".root"; TString parFile = outDir + "sim/params_" + sfileNum + ".root"; TString geoFileNamePsd = outDir + "geo/psd_geo_xy_" + sfileNum + ".txt"; TString geoFileName = outDir + "geo/geofile_" + sfileNum + ".root"; TString SourceDir = gSystem->Getenv("VMCWORKDIR"); TString setupFile = SourceDir + "/geometry/setup/sis100_electron_setup.C"; //TODO TString setupFunct = setup; setupFunct += "_setup()"; gROOT->LoadMacro(setupFile); gInterpreter->ProcessLine(setupFunct); // Function needed for CTest runtime dependency // TString depFile = Remove_CTest_Dependency_File(outDir, "run_sim" , setup); // --- Logger settings ---------------------------------------------------- TString logLevel = "INFO"; // "DEBUG"; TString logVerbosity = "LOW"; // ------------------------------------------------------------------------ // --- Define the target geometry ----------------------------------------- // // The target is not part of the setup, since one and the same setup can // and will be used with different targets. // The target is constructed as a tube in z direction with the specified // diameter (in x and y) and thickness (in z). It will be placed at the // specified position as daughter volume of the volume present there. It is // in the responsibility of the user that no overlaps or extrusions are // created by the placement of the target. // TString targetElement = "Gold"; Double_t targetThickness = 0.025; // full thickness in cm Double_t targetDiameter = 2.5; // diameter in cm Double_t targetPosX = 0.; // target x position in global c.s. [cm] Double_t targetPosY = 0.; // target y position in global c.s. [cm] Double_t targetPosZ = 0.; // target z position in global c.s. [cm] Double_t targetRotY = 0.; // target rotation angle around the y axis [deg] // ------------------------------------------------------------------------ // --- Define the creation of the primary vertex ------------------------ // // By default, the primary vertex point is sampled from a Gaussian // distribution in both x and y with the specified beam profile width, // and from a flat distribution in z over the extension of the target. // By setting the respective flags to kFALSE, the primary vertex will always // at the (0., 0.) in x and y and in the z centre of the target, respectively. // Bool_t smearVertexXY = kTRUE; Bool_t smearVertexZ = kTRUE; Double_t beamWidthX = 1.; // Gaussian sigma of the beam profile in x [cm] Double_t beamWidthY = 1.; // Gaussian sigma of the beam profile in y [cm] // ------------------------------------------------------------------------ // In general, the following parts need not be touched // ======================================================================== cout << "[INFO ] Setup: " << setup << endl; // ---- Debug option ------------------------------------------------- gDebug = 0; // ------------------------------------------------------------------------ // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ------------------------------------------------------------------------ // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName("TGeant4"); // Transport engine run->SetOutputFile(outFile); // Output file run->SetGenerateRunInfo(kTRUE); // Create FairRunInfo file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // ------------------------------------------------------------------------ // ----- Logger settings ---------------------------------------------- gLogger->SetLogScreenLevel(logLevel.Data()); gLogger->SetLogVerbosityLevel(logVerbosity.Data()); // ------------------------------------------------------------------------ // ----- Create media ------------------------------------------------- run->SetMaterials("media.geo"); // Materials // ------------------------------------------------------------------------ // ----- Create detectors and passive volumes ------------------------- if ( caveGeom != "" ) { FairModule* cave = new CbmCave("CAVE"); cave->SetGeometryFileName(caveGeom); run->AddModule(cave); } if ( pipeGeom != "" ) { FairModule* pipe = new CbmPipe("PIPE"); pipe->SetGeometryFileName(pipeGeom); run->AddModule(pipe); } // --- Target CbmTarget* target = new CbmTarget(targetElement.Data(), targetThickness, targetDiameter); target->SetPosition(targetPosX, targetPosY, targetPosZ); target->SetRotation(targetRotY); run->AddModule(target); if ( magnetGeom != "" ) { FairModule* magnet = new CbmMagnet("MAGNET"); magnet->SetGeometryFileName(magnetGeom); run->AddModule(magnet); } if ( platformGeom != "" ) { FairModule* platform = new CbmPlatform("PLATFORM"); platform->SetGeometryFileName(platformGeom); run->AddModule(platform); } if ( mvdGeom != "" ) { FairDetector* mvd = new CbmMvd("MVD", kTRUE); mvd->SetGeometryFileName(mvdGeom); mvd->SetMotherVolume("pipevac1"); run->AddModule(mvd); } if ( stsGeom != "" ) { FairDetector* sts = new CbmStsMC(kTRUE); sts->SetGeometryFileName(stsGeom); run->AddModule(sts); } if ( richGeom != "" ) { FairDetector* rich = new CbmRich("RICH", kTRUE); rich->SetGeometryFileName(richGeom); run->AddModule(rich); } if ( muchGeom != "" ) { FairDetector* much = new CbmMuch("MUCH", kTRUE); much->SetGeometryFileName(muchGeom); run->AddModule(much); } if ( shieldGeom != "" ) { FairModule* shield = new CbmShield("SHIELD"); shield->SetGeometryFileName(shieldGeom); run->AddModule(shield); } if ( trdGeom != "" ) { FairDetector* trd = new CbmTrd("TRD",kTRUE ); trd->SetGeometryFileName(trdGeom); run->AddModule(trd); } if ( tofGeom != "" ) { FairDetector* tof = new CbmTof("TOF", kTRUE); tof->SetGeometryFileName(tofGeom); run->AddModule(tof); } if ( ecalGeom != "" ) { FairDetector* ecal = new CbmEcal("ECAL", kTRUE, ecalGeom.Data()); run->AddModule(ecal); } // if ( psdGeom != "" ) { TString geoFileNamePsd = outDir + "geo/psd_geo_xy_" + sfileNum + ".txt"; cout << "Constructing PSD" << endl; // CbmPsdv1* psd= new CbmPsdv1("PSD", kTRUE); CbmPsdTest* psd= new CbmPsdTest("PSD", kTRUE); psd->SetZposition(psdZpos); // in cm psd->SetXshift(psdXpos); // in cm psd->SetGeoFile(geoFileNamePsd); psd->SetHoleSize(6); run->AddModule(psd); // } // ------------------------------------------------------------------------ // ----- Create magnetic field ---------------------------------------- CbmFieldMap* magField = NULL; if ( 2 == fieldSymType ) { magField = new CbmFieldMapSym2(fieldMap); } else if ( 3 == fieldSymType ) { magField = new CbmFieldMapSym3(fieldMap); } magField->SetPosition(0., 0., fieldZ); magField->SetScale(fieldScale); run->SetField(magField); // ------------------------------------------------------------------------ // ----- Create PrimaryGenerator -------------------------------------- FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); // --- Uniform distribution of event plane angle // primGen->SetEventPlane(0., 2. * TMath::Pi()); //TODO (ask Vitaly) check event plane // --- Get target parameters Double_t tX = 0.; Double_t tY = 0.; Double_t tZ = 0.; Double_t tDz = 0.; if ( target ) { target->GetPosition(tX, tY, tZ); tDz = target->GetThickness(); } primGen->SetTarget(tZ, tDz); primGen->SetBeam(0., 0., beamWidthX, beamWidthY); primGen->SmearGausVertexXY(smearVertexXY); primGen->SmearVertexZ(smearVertexZ); // // TODO: Currently, there is no guaranteed consistency of the beam profile // and the transversal target dimension, i.e., that the sampled primary // vertex falls into the target volume. This would require changes // in the FairPrimaryGenerator class. // ------------------------------------------------------------------------ // Use the CbmUnigenGenrator for the input if (gen == 0) { CbmUnigenGenerator* urqmdGen = new CbmUnigenGenerator(inFile); urqmdGen->SetEventPlane(-TMath::Pi(), TMath::Pi()); primGen->AddGenerator(urqmdGen); } if (gen == 1) { CbmShieldGeneratorNew* shieldGen = new CbmShieldGeneratorNew (inFile); primGen->AddGenerator(shieldGen); } run->SetGenerator(primGen); // ------------------------------------------------------------------------ // Visualisation of trajectories (TGeoManager Only) // Switch this on if you want to visualise tracks in the event display. // This is normally switch off, because of the huge files created // when it is switched on. run->SetStoreTraj(kFALSE); // ----- Run initialisation ------------------------------------------- run->Init(); // ------------------------------------------------------------------------ // Set cuts for storing the trajectories. // Switch this on only if trajectories are stored. // Choose this cuts according to your needs, but be aware // that the file size of the output file depends on these cuts FairTrajFilter* trajFilter = FairTrajFilter::Instance(); if ( trajFilter ) { trajFilter->SetStepSizeCut(0.01); // 1 cm trajFilter->SetVertexCut(-2000., -2000., 4., 2000., 2000., 100.); trajFilter->SetMomentumCutP(10e-3); // p_lab > 10 MeV trajFilter->SetEnergyCut(0., 1.02); // 0 < Etot < 1.04 GeV trajFilter->SetStorePrimaries(kTRUE); trajFilter->SetStoreSecondaries(kTRUE); } // ----- Runtime database --------------------------------------------- CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar"); fieldPar->SetParameters(magField); fieldPar->setChanged(); fieldPar->setInputVersion(run->GetRunId(),1); Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ------------------------------------------------------------------------ // ----- Start run ---------------------------------------------------- run->Run(nEvents); // ------------------------------------------------------------------------ run->CreateGeometryFile(geoFileName); // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); std::cout << std::endl << std::endl; std::cout << "Macro finished successfully." << std::endl; std::cout << "Output file is " << outFile << std::endl; std::cout << "Parameter file is " << parFile << std::endl; std::cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << std::endl << std::endl; // ------------------------------------------------------------------------ std::cout << " Test passed" << std::endl; std::cout << " All ok " << std::endl; // Function needed for CTest runtime dependency // Generate_CTest_Dependency_File(depFile); }
void run_sim_tpc(Int_t nEvents = 10, TString mcEngine = "TGeant3") { TString dir = getenv("VMCWORKDIR"); TString geom_dir = dir + "/Detectors/Geometry/"; gSystem->Setenv("GEOMPATH",geom_dir.Data()); TString tut_configdir = dir + "/Detectors/gconfig"; gSystem->Setenv("CONFIG_DIR",tut_configdir.Data()); // Output file name char fileout[100]; sprintf(fileout, "AliceO2_%s.tpc.mc_%i_event.root", mcEngine.Data(), nEvents); TString outFile = fileout; // Parameter file name char filepar[100]; sprintf(filepar, "AliceO2_%s.tpc.params_%i.root", mcEngine.Data(), nEvents); TString parFile = filepar; // In general, the following parts need not be touched // Debug option gDebug = 0; // Timer TStopwatch timer; timer.Start(); // Create simulation run FairRunSim* run = new FairRunSim(); run->SetName(mcEngine); // Transport engine run->SetOutputFile(outFile); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // Create media run->SetMaterials("media.geo"); // Materials // Create geometry AliceO2::Passive::Cave* cave = new AliceO2::Passive::Cave("CAVE"); cave->SetGeometryFileName("cave.geo"); run->AddModule(cave); // ===| Add TPC |============================================================ AliceO2::TPC::Detector* tpc = new AliceO2::TPC::Detector("TPC", kTRUE); tpc->SetGeoFileName("TPCGeometry.root"); run->AddModule(tpc); // Create PrimaryGenerator FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); FairBoxGenerator* boxGen = new FairBoxGenerator(2212, 1); /*protons*/ //boxGen->SetThetaRange(0.0, 90.0); boxGen->SetEtaRange(-0.9,0.9); boxGen->SetPRange(100, 100.01); boxGen->SetPhiRange(0., 360.); boxGen->SetDebug(kTRUE); primGen->AddGenerator(boxGen); run->SetGenerator(primGen); // store track trajectories // run->SetStoreTraj(kTRUE); // Initialize simulation run run->Init(); // Runtime database Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // Start run run->Run(nEvents); // run->CreateGeometryFile("geofile_full.root"); // Finish timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << outFile << endl; cout << "Parameter file is " << parFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; }
void r3ball_batch(Int_t nEvents = 1, TObjArray& fDetList, TString Target = "LeadTarget", Bool_t fVis=kFALSE, TString fMC="TGeant3", TString fGenerator="box", Bool_t fUserPList= kFALSE, Bool_t fR3BMagnet= kTRUE, Double_t fEnergyP=1.0, Int_t fMult=1, Int_t fGeoVer=5, Double_t fNonUni=1.0 ) { TString dir = getenv("VMCWORKDIR"); TString r3bdir = dir + "/macros"; TString r3b_geomdir = dir + "/geometry"; gSystem->Setenv("GEOMPATH",r3b_geomdir.Data()); TString r3b_confdir = dir + "gconfig"; gSystem->Setenv("CONFIG_DIR",r3b_confdir.Data()); // Output files TString OutFile = "r3bsim.root"; TString ParFile = "r3bpar.root"; // In general, the following parts need not be touched // ======================================================================== // ---- Debug option ------------------------------------------------- gDebug = 0; // ------------------------------------------------------------------------ // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ------------------------------------------------------------------------ // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName(fMC.Data()); // Transport engine run->SetOutputFile(OutFile.Data()); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // R3B Special Physics List in G4 case if ( (fUserPList == kTRUE ) && (fMC.CompareTo("TGeant4") == 0) ){ run->SetUserConfig("g4R3bConfig.C"); run->SetUserCuts("SetR3BCuts.C"); } // ----- Create media ------------------------------------------------- run->SetMaterials("media_r3b.geo"); // Materials // Magnetic field map type Int_t fFieldMap = 0; // Global Transformations //- Two ways for a Volume Rotation are supported //-- 1) Global Rotation (Euler Angles definition) //-- This represent the composition of : first a rotation about Z axis with //-- angle phi, then a rotation with theta about the rotated X axis, and //-- finally a rotation with psi about the new Z axis. Double_t phi,theta,psi; //-- 2) Rotation in Ref. Frame of the Volume //-- Rotation is Using Local Ref. Frame axis angles Double_t thetaX,thetaY,thetaZ; //- Global Translation Lab. frame. Double_t tx,ty,tz; // - Polar angular limits Double_t minTheta=35., maxTheta=55.; // ----- Create R3B geometry -------------------------------------------- //R3B Cave definition FairModule* cave= new R3BCave("CAVE"); cave->SetGeometryFileName("r3b_cave.geo"); run->AddModule(cave); //R3B Target definition if (fDetList.FindObject("TARGET") ) { R3BModule* target= new R3BTarget(Target.Data()); // Global Lab. Rotation phi = 0.0; // (deg) theta = 0.0; // (deg) psi = 0.0; // (deg) // Rotation in Ref. Frame. thetaX = 0.0; // (deg) thetaY = 0.0; // (deg) thetaZ = 0.0; // (deg) // Global translation in Lab tx = 0.0; // (cm) ty = 0.0; // (cm) tz = 0.0; // (cm) //target->SetRotAnglesEuler(phi,theta,psi); target->SetRotAnglesXYZ(thetaX,thetaY,thetaZ); target->SetTranslation(tx,ty,tz); run->AddModule(target); } //R3B Magnet definition if (fDetList.FindObject("ALADIN") ) { fFieldMap = 0; R3BModule* mag = new R3BMagnet("AladinMagnet"); mag->SetGeometryFileName("aladin_v13a.geo.root"); run->AddModule(mag); } //R3B Magnet definition if (fDetList.FindObject("GLAD") ) { fFieldMap = 1; R3BModule* mag = new R3BGladMagnet("GladMagnet"); // Global position of the Module phi = 0.0; // (deg) theta = 0.0; // (deg) psi = 0.0; // (deg) // Rotation in Ref. Frame. thetaX = 0.0; // (deg) thetaY = 0.0; // (deg) thetaZ = 0.0; // (deg) // Global translation in Lab tx = 0.0; // (cm) ty = 0.0; // (cm) tz = 0.0; // (cm) //mag->SetRotAnglesEuler(phi,theta,psi); mag->SetRotAnglesXYZ(thetaX,thetaY,thetaZ); mag->SetTranslation(tx,ty,tz); run->AddModule(mag); } if (fDetList.FindObject("CRYSTALBALL") ) { //R3B Crystal Calorimeter R3BDetector* xball = new R3BXBall("XBall", kTRUE); xball->SetGeometryFileName("cal_v13a.geo.root"); run->AddModule(xball); } if (fDetList.FindObject("CALIFA") ) { // CALIFA Calorimeter R3BDetector* calo = new R3BCalo("Califa", kTRUE); ((R3BCalo *)calo)->SelectGeometryVersion(10); //Selecting the Non-uniformity of the crystals (1 means +-1% max deviation) ((R3BCalo *)calo)->SetNonUniformity(1.0); calo->SetGeometryFileName("califa_v13_811.geo.root"); run->AddModule(calo); } // Tracker if (fDetList.FindObject("TRACKER") ) { R3BDetector* tra = new R3BTra("Tracker", kTRUE); // Global position of the Module phi = 0.0; // (deg) theta = 0.0; // (deg) psi = 0.0; // (deg) // Rotation in Ref. Frame. thetaX = 0.0; // (deg) thetaY = 0.0; // (deg) thetaZ = 0.0; // (deg) // Global translation in Lab tx = 0.0; // (cm) ty = 0.0; // (cm) tz = 0.0; // (cm) //tra->SetRotAnglesEuler(phi,theta,psi); tra->SetRotAnglesXYZ(thetaX,thetaY,thetaZ); tra->SetTranslation(tx,ty,tz); // User defined Energy CutOff Double_t fCutOffSi = 1.0e-06; // Cut-Off -> 10KeV only in Si ((R3BTra*) tra)->SetEnergyCutOff(fCutOffSi); run->AddModule(tra); } // DCH drift chambers if (fDetList.FindObject("DCH") ) { R3BDetector* dch = new R3BDch("Dch", kTRUE); ((R3BDch*) dch )->SetHeliumBag(kTRUE); // Global position of the Module phi = 0.0; // (deg) theta = 0.0; // (deg) psi = 0.0; // (deg) // Rotation in Ref. Frame. thetaX = 0.0; // (deg) thetaY = 0.0; // (deg) thetaZ = 0.0; // (deg) // Global translation in Lab tx = 0.0; // (cm) ty = 0.0; // (cm) tz = 0.0; // (cm) //dch->SetRotAnglesEuler(phi,theta,psi); dch->SetRotAnglesXYZ(thetaX,thetaY,thetaZ); dch->SetTranslation(tx,ty,tz); run->AddModule(dch); } // Tof if (fDetList.FindObject("TOF") ) { R3BDetector* tof = new R3BTof("Tof", kTRUE); // Global position of the Module thetaX = 0.0; // (deg) thetaY = 0.0; // (deg) thetaZ = 0.0; // (deg) // Rotation in Ref. Frame. thetaX = 0.0; // (deg) thetaY = 0.0; // (deg) thetaZ = 0.0; // (deg) // Global translation in Lab tx = 0.0; // (cm) ty = 0.0; // (cm) tz = 0.0; // (cm) tof->SetRotAnglesXYZ(thetaX,thetaY,thetaZ); tof->SetTranslation(tx,ty,tz); // User defined Energy CutOff Double_t fCutOffSci = 1.0e-05; // Cut-Off -> 10.KeV only in Sci. ((R3BTof*) tof)->SetEnergyCutOff(fCutOffSci); run->AddModule(tof); } // mTof if (fDetList.FindObject("MTOF") ) { R3BDetector* mTof = new R3BmTof("mTof", kTRUE); // Global position of the Module phi = 0.0; // (deg) theta = 0.0; // (deg) psi = 0.0; // (deg) // Rotation in Ref. Frame. thetaX = 0.0; // (deg) thetaY = 0.0; // (deg) thetaZ = 0.0; // (deg) // Global translation in Lab tx = 0.0; // (cm) ty = 0.0; // (cm) tz = 0.0; // (cm) //mTof->SetRotAnglesEuler(phi,theta,psi); mTof->SetRotAnglesXYZ(thetaX,thetaY,thetaZ); mTof->SetTranslation(tx,ty,tz); // User defined Energy CutOff Double_t fCutOffSci = 1.0e-05; // Cut-Off -> 10.KeV only in Sci. ((R3BmTof*) mTof)->SetEnergyCutOff(fCutOffSci); run->AddModule(mTof); } // GFI detector if (fDetList.FindObject("GFI") ) { R3BDetector* gfi = new R3BGfi("Gfi", kTRUE); // Global position of the Module phi = 0.0; // (deg) theta = 0.0; // (deg) psi = 0.0; // (deg) // Rotation in Ref. Frame. thetaX = 0.0; // (deg) thetaY = 0.0; // (deg) thetaZ = 0.0; // (deg) // Global translation in Lab tx = 0.0; // (cm) ty = 0.0; // (cm) tz = 0.0; // (cm) gfi->SetRotAnglesXYZ(thetaX,thetaY,thetaZ); gfi->SetTranslation(tx,ty,tz); // User defined Energy CutOff Double_t fCutOffSci = 1.0e-05; // Cut-Off -> 10.KeV only in Sci. ((R3BGfi*) gfi)->SetEnergyCutOff(fCutOffSci); run->AddModule(gfi); } // Land Detector if (fDetList.FindObject("LAND") ) { R3BDetector* land = new R3BLand("Land", kTRUE); land->SetGeometryFileName("land_v12a_10m.geo.root"); run->AddModule(land); } // Chimera if (fDetList.FindObject("CHIMERA") ) { R3BDetector* chim = new R3BChimera("Chimera", kTRUE); chim->SetGeometryFileName("chimera.root"); // Global position of the Module thetaX = 0.0; // (deg) thetaY = 0.0; // (deg) thetaZ = 0.0; // (deg) // Rotation in Ref. Frame. thetaX = 0.0; // (deg) thetaY = 0.0; // (deg) thetaZ = 0.0; // (deg) // Global translation in Lab tx = 0.0; // (cm) ty = 0.0; // (cm) tz = 0.0; // (cm) chim->SetRotAnglesXYZ(thetaX,thetaY,thetaZ); chim->SetTranslation(tx,ty,tz); // User defined Energy CutOff //Double_t fCutOffSci = 1.0e-05; // Cut-Off -> 10.KeV only in Sci. //((R3BChimera*) chim)->SetEnergyCutOff(fCutOffSci); run->AddModule(chim); } // Luminosity detector if (fDetList.FindObject("LUMON") ) { R3BDetector* lumon = new ELILuMon("LuMon", kTRUE); //lumon->SetGeometryFileName("lumon.root"); // Global position of the Module thetaX = 0.0; // (deg) thetaY = 0.0; // (deg) thetaZ = 0.0; // (deg) // Rotation in Ref. Frame. thetaX = 0.0; // (deg) thetaY = 0.0; // (deg) thetaZ = 0.0; // (deg) // Global translation in Lab tx = 0.0; // (cm) ty = 0.0; // (cm) tz = 200.0; // (cm) lumon->SetRotAnglesXYZ(thetaX,thetaY,thetaZ); lumon->SetTranslation(tx,ty,tz); // User defined Energy CutOff //Double_t fCutOffSci = 1.0e-05; // Cut-Off -> 10.KeV only in Sci. //((ELILuMon*) lumon)->SetEnergyCutOff(fCutOffSci); run->AddModule(lumon); } // ----- Create R3B magnetic field ---------------------------------------- Int_t typeOfMagneticField = 0; Int_t fieldScale = 1; Bool_t fVerbose = kFALSE; //NB: <D.B> // If the Global Position of the Magnet is changed // the Field Map has to be transformed accordingly if (fFieldMap == 0) { R3BFieldMap* magField = new R3BFieldMap(typeOfMagneticField,fVerbose); magField->SetPosition(0., 0., 0.); magField->SetScale(fieldScale); if ( fR3BMagnet == kTRUE ) { run->SetField(magField); } else { run->SetField(NULL); } } else if(fFieldMap == 1){ R3BGladFieldMap* magField = new R3BGladFieldMap("R3BGladMap"); magField->SetPosition(0., 0., +350-119.94); magField->SetScale(fieldScale); if ( fR3BMagnet == kTRUE ) { run->SetField(magField); } else { run->SetField(NULL); } } //! end of field map section // ----- Create PrimaryGenerator -------------------------------------- // 1 - Create the Main API class for the Generator FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); if (fGenerator.CompareTo("box") == 0 ) { // 2- Define the BOX generator Double_t pdgId=211; // pion beam Double_t theta1= 0.; // polar angle distribution Double_t theta2= 7.; Double_t momentum=.8; // 10 GeV/c FairBoxGenerator* boxGen = new FairBoxGenerator(pdgId, 50); boxGen->SetThetaRange ( theta1, theta2); boxGen->SetPRange (momentum,momentum*2.); boxGen->SetPhiRange (0.,360.); boxGen->SetXYZ(0.0,0.0,-1.5); // add the box generator primGen->AddGenerator(boxGen); } if (fGenerator.CompareTo("gammas") == 0 ) { // 2- Define the CALIFA Test gamma generator Double_t pdgId=22; // 22 for gamma emission, 2212 for proton emission Double_t theta1=minTheta; // polar angle distribution: lower edge Double_t theta2=maxTheta; // polar angle distribution: upper edge Double_t momentum=fEnergyP; // GeV/c //Double_t momentum=0.808065; // 0.808065 GeV/c (300MeV Kin Energy for protons) //Double_t momentum=0.31016124; // 0.31016124 GeV/c (50MeV Kin Energy for protons) //Double_t momentum=0.4442972; // 0.4442972 GeV/c (100MeV Kin Energy for protons) //Double_t momentum=0.5509999; // 0.5509999 GeV/c (150MeV Kin Energy for protons) //Double_t momentum=0.64405; // 0.64405 GeV/c (200MeV Kin Energy for protons) Int_t multiplicity = fMult; R3BCALIFATestGenerator* gammasGen = new R3BCALIFATestGenerator(pdgId, multiplicity); gammasGen->SetThetaRange(theta1,theta2); gammasGen->SetCosTheta(); gammasGen->SetPRange(momentum,momentum); gammasGen->SetPhiRange(0.,360.); gammasGen->SetBoxXYZ(-0.1,0.1,-0.1,0.1,-0.1,0.1); gammasGen->SetLorentzBoost(0.8197505718204776); //beta=0.81975 for 700 A MeV // add the gamma generator primGen->AddGenerator(gammasGen); } if (fGenerator.CompareTo("r3b") == 0 ) { R3BSpecificGenerator *pR3bGen = new R3BSpecificGenerator(); // R3bGen properties pR3bGen->SetBeamInteractionFlag("off"); pR3bGen->SetBeamInteractionFlag("off"); pR3bGen->SetRndmFlag("off"); pR3bGen->SetRndmEneFlag("off"); pR3bGen->SetBoostFlag("off"); pR3bGen->SetReactionFlag("on"); pR3bGen->SetGammasFlag("off"); pR3bGen->SetDecaySchemeFlag("off"); pR3bGen->SetDissociationFlag("off"); pR3bGen->SetBackTrackingFlag("off"); pR3bGen->SetSimEmittanceFlag("off"); // R3bGen Parameters pR3bGen->SetBeamEnergy(1.); // Beam Energy in GeV pR3bGen->SetSigmaBeamEnergy(1.e-03); // Sigma(Ebeam) GeV pR3bGen->SetParticleDefinition(2212); // Use Particle Pdg Code pR3bGen->SetEnergyPrim(0.3); // Particle Energy in MeV Int_t fMultiplicity = 50; pR3bGen->SetNumberOfParticles(fMultiplicity); // Mult. // Reaction type // 1: "Elas" // 2: "iso" // 3: "Trans" pR3bGen->SetReactionType("Elas"); // Target type // 1: "LeadTarget" // 2: "Parafin0Deg" // 3: "Parafin45Deg" // 4: "LiH" pR3bGen->SetTargetType(Target.Data()); Double_t thickness = (0.11/2.)/10.; // cm pR3bGen->SetTargetHalfThicknessPara(thickness); // cm pR3bGen->SetTargetThicknessLiH(3.5); // cm pR3bGen->SetTargetRadius(1.); // cm pR3bGen->SetSigmaXInEmittance(1.); //cm pR3bGen->SetSigmaXPrimeInEmittance(0.0001); //cm // Dump the User settings pR3bGen->PrintParameters(); primGen->AddGenerator(pR3bGen); } run->SetGenerator(primGen); //-------Set visualisation flag to true------------------------------------ if (fVis==kTRUE){ run->SetStoreTraj(kTRUE); }else{ run->SetStoreTraj(kFALSE); } // ----- Initialize simulation run ------------------------------------ run->Init(); // ------ Increase nb of step for CALO Int_t nSteps = -15000; gMC->SetMaxNStep(nSteps); // ----- Runtime database --------------------------------------------- Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(ParFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ----- Start run ---------------------------------------------------- if (nEvents>0) run->Run(nEvents); // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << OutFile << endl; cout << "Parameter file is " << ParFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; // ------------------------------------------------------------------------ cout << " Test passed" << endl; cout << " All ok " << endl; }
void run_sim(Int_t nEvents = 100, TString mcEngine = "TGeant4") { // Output file name TString outFile ="test.root"; // Parameter file name TString parFile="params.root"; // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ------------------------------------------------------------------------ // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName(mcEngine); // Transport engine run->SetOutputFile(new FairRootFileSink(outFile)); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // ------------------------------------------------------------------------ // ----- Create media ------------------------------------------------- run->SetMaterials("media.geo"); // Materials // ------------------------------------------------------------------------ // ----- Create geometry ---------------------------------------------- FairModule* cave= new MyCave("CAVE"); cave->SetGeometryFileName("cave.geo"); run->AddModule(cave); FairModule* magnet = new MyMagnet("Magnet"); run->AddModule(magnet); FairModule* pipe = new MyPipe("Pipe"); run->AddModule(pipe); FairDetector* NewDet = new NewDetector("TestDetector", kTRUE); run->AddModule(NewDet); // ------------------------------------------------------------------------ // ----- Magnetic field ------------------------------------------- // Constant Field MyConstField *fMagField = new MyConstField(); fMagField->SetField(0., 20. ,0. ); // values are in kG fMagField->SetFieldRegion(-200, 200,-200, 200, -200, 200); // values are in cm // (xmin,xmax,ymin,ymax,zmin,zmax) run->SetField(fMagField); // -------------------------------------------------------------------- // ----- Create PrimaryGenerator -------------------------------------- FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); // Add a box generator also to the run FairBoxGenerator* boxGen = new FairBoxGenerator(13, 5); // 13 = muon; 1 = multipl. boxGen->SetPRange(20,25); // GeV/c boxGen->SetPhiRange(0., 360.); // Azimuth angle range [degree] boxGen->SetThetaRange(0., 90.); // Polar angle in lab system range [degree] boxGen->SetXYZ(0., 0., 0.); // cm primGen->AddGenerator(boxGen); run->SetGenerator(primGen); // ------------------------------------------------------------------------ //---Store the visualiztion info of the tracks, this make the output file very large!! //--- Use it only to display but not for production! run->SetStoreTraj(kTRUE); // ----- Initialize simulation run ------------------------------------ run->Init(); // ------------------------------------------------------------------------ // ----- Runtime database --------------------------------------------- Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ------------------------------------------------------------------------ // ----- Start run ---------------------------------------------------- run->Run(nEvents); //You can export your ROOT geometry ot a separate file run->CreateGeometryFile("geofile_full.root"); // ------------------------------------------------------------------------ // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << outFile << endl; cout << "Parameter file is " << parFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; // ------------------------------------------------------------------------ }
void tut_ana_mclist(int nevts=0) { // *** some variables int i=0,j=0, k=0, l=0; TString OutFile="output.root"; // *** the files coming from the simulation TString inPidFile = "pid_complete.root"; // this file contains the PndPidCandidates and McTruth TString inParFile = "simparams.root"; gStyle->SetOptFit(1011); // *** PID table with selection thresholds; can be modified by the user TString pidParFile = TString(gSystem->Getenv("VMCWORKDIR"))+"/macro/params/all.par"; // *** initialization FairLogger::GetLogger()->SetLogToFile(kFALSE); FairRunAna* fRun = new FairRunAna(); FairRuntimeDb* rtdb = fRun->GetRuntimeDb(); fRun->SetInputFile(inPidFile); // *** setup parameter database FairParRootFileIo* parIO = new FairParRootFileIo(); parIO->open(inParFile); FairParAsciiFileIo* parIOPid = new FairParAsciiFileIo(); parIOPid->open(pidParFile.Data(),"in"); rtdb->setFirstInput(parIO); rtdb->setSecondInput(parIOPid); rtdb->setOutput(parIO); fRun->SetOutputFile(OutFile); fRun->Init(); // // Now the analysis stuff comes... // // *** the data reader object PndAnalysis* theAnalysis = new PndAnalysis(); if (nevts==0) nevts= theAnalysis->GetEntries(); // *** RhoCandLists for the analysis RhoCandList mctruth; // *** // the event loop // *** while (theAnalysis->GetEvent() && i++<nevts) { cout<<"****** Evt " << i << endl; // *** the MC Truth objects theAnalysis->FillList(mctruth,"McTruth"); // // Print MC Truth list with mother-daughter relations // for (j=0;j<mctruth.GetLength();++j) { RhoCandidate *mcmother = mctruth[j]->TheMother(); int muid = -1; if (mcmother) muid = mcmother->GetTrackNumber(); cout << "Track "<< mctruth[j]->GetTrackNumber()<<" (PDG:"<<mctruth[j]->PdgCode() <<") has mother "<<muid; if (mctruth[j]->NDaughters()>0) cout <<" and daughter(s) "; for (k=0;k<mctruth[j]->NDaughters();++k) cout <<mctruth[j]->Daughter(k)->GetTrackNumber()<<" "; cout<<endl; } cout <<endl; } }
void run_sim() { TString transport = "TGeant4"; Bool_t userPList = kFALSE; // option for TGeant4 TString outFile = "sim.root"; TString parFile = "par.root"; Bool_t magnet = kTRUE; Float_t fieldScale = -0.68; TString generator1 = "box"; TString generator2 = "ascii"; TString generator3 = "r3b"; TString generator = generator1; TString inputFile = ""; Int_t nEvents = 1; Bool_t storeTrajectories = kTRUE; Int_t randomSeed = 335566; // 0 for time-dependent random numbers // Target type TString target1 = "LeadTarget"; TString target2 = "Para"; TString target3 = "Para45"; TString target4 = "LiH"; TString targetType = target4; // ------------------------------------------------------------------------ // Stable part ------------------------------------------------------------ TString dir = getenv("VMCWORKDIR"); // ---- Debug option ------------------------------------------------- gDebug = 0; // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName(transport); // Transport engine run->SetOutputFile(outFile.Data()); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // R3B Special Physics List in G4 case if ((userPList == kTRUE) && (transport.CompareTo("TGeant4") == 0)) { run->SetUserConfig("g4R3bConfig.C"); run->SetUserCuts("SetCuts.C"); } // ----- Create media ------------------------------------------------- run->SetMaterials("media_r3b.geo"); // Materials // ----- Create R3B geometry -------------------------------------------- // R3B Cave definition FairModule* cave = new R3BCave("CAVE"); cave->SetGeometryFileName("r3b_cave.geo"); run->AddModule(cave); // To skip the detector comment out the line with: run->AddModule(... // Target run->AddModule(new R3BTarget(targetType, "target_" + targetType + ".geo.root")); // GLAD //run->AddModule(new R3BGladMagnet("glad_v17_flange.geo.root")); // GLAD should not be moved or rotated // PSP run->AddModule(new R3BPsp("psp_v13a.geo.root", {}, -221., -89., 94.1)); // R3B SiTracker Cooling definition //run->AddModule(new R3BVacVesselCool(targetType, "vacvessel_v14a.geo.root")); // STaRTrack //run->AddModule(new R3BSTaRTra("startra_v16-300_2layers.geo.root", { 0., 0., 20. })); // CALIFA R3BCalifa* califa = new R3BCalifa("califa_10_v8.11.geo.root"); califa->SelectGeometryVersion(10); // Selecting the Non-uniformity of the crystals (1 means +-1% max deviation) califa->SetNonUniformity(1.0); //run->AddModule(califa); // Tof //run->AddModule(new R3BTof("tof_v17a.geo.root", { -417.359574, 2.400000, 960.777114 }, { "", -90., +31., 90. })); // mTof run->AddModule(new R3BmTof("mtof_v17a.geo.root", { -155.824045, 0.523976, 761.870346 }, { "", -90., +16.7, 90. })); // MFI //run->AddModule(new R3BMfi("mfi_v17a.geo.root", { -63.82, 0., 520.25 }, { "", 90., +13.5, 90. })); // s412 // NeuLAND // run->AddModule(new R3BNeuland("neuland_test.geo.root", { 0., 0., 1400. + 12 * 5. })); // ----- Create R3B magnetic field ---------------------------------------- // NB: <D.B> // If the Global Position of the Magnet is changed // the Field Map has to be transformed accordingly R3BGladFieldMap* magField = new R3BGladFieldMap("R3BGladMap"); magField->SetScale(fieldScale); if (magnet == kTRUE) { run->SetField(magField); } else { run->SetField(NULL); } // ----- Create PrimaryGenerator -------------------------------------- // 1 - Create the Main API class for the Generator FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); if (generator.CompareTo("box") == 0) { FairIonGenerator* boxGen = new FairIonGenerator(50, 128, 50, 1, 0., 0., 1.3, 0., 0., 0.); primGen->AddGenerator(boxGen); } if (generator.CompareTo("ascii") == 0) { R3BAsciiGenerator* gen = new R3BAsciiGenerator((dir + "/input/" + inputFile).Data()); primGen->AddGenerator(gen); } run->SetGenerator(primGen); run->SetStoreTraj(storeTrajectories); FairLogger::GetLogger()->SetLogVerbosityLevel("LOW"); FairLogger::GetLogger()->SetLogScreenLevel("INFO"); // ----- Initialize simulation run ------------------------------------ run->Init(); TVirtualMC::GetMC()->SetRandom(new TRandom3(randomSeed)); // ------ Increase nb of step for CALO Int_t nSteps = -15000; TVirtualMC::GetMC()->SetMaxNStep(nSteps); // ----- Runtime database --------------------------------------------- R3BFieldPar* fieldPar = (R3BFieldPar*)rtdb->getContainer("R3BFieldPar"); if (NULL != magField) { fieldPar->SetParameters(magField); fieldPar->setChanged(); } Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ----- Start run ---------------------------------------------------- if (nEvents > 0) { run->Run(nEvents); } // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "Macro finished succesfully." << endl; cout << "Output file is " << outFile << endl; cout << "Parameter file is " << parFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; cout << " Test passed" << endl; cout << " All ok " << endl; // Snap a picture of the geometry // If this crashes, set "OpenGL.SavePicturesViaFBO: no" in your .rootrc /*gStyle->SetCanvasPreferGL(kTRUE); gGeoManager->GetTopVolume()->Draw("ogl"); TGLViewer* v = (TGLViewer*)gPad->GetViewer3D(); v->SetStyle(TGLRnrCtx::kOutline); v->RequestDraw(); v->SavePicture("run_sim-side.png"); v->SetPerspectiveCamera(TGLViewer::kCameraPerspXOZ, 25., 0, 0, -90. * TMath::DegToRad(), 0. * TMath::DegToRad()); v->SavePicture("run_sim-top.png");*/ }
void run_sim(Int_t nEvents = 10, TString mcEngine = "TGeant3", Int_t fileId = 0) { TString dir = getenv("VMCWORKDIR"); TString tutdir = dir + "/MQ/9-PixelDetector"; TString tut_geomdir = dir + "/common/geometry"; gSystem->Setenv("GEOMPATH",tut_geomdir.Data()); TString tut_configdir = dir + "/common/gconfig"; gSystem->Setenv("CONFIG_DIR",tut_configdir.Data()); TString partName[] = {"pions","eplus","proton"}; Int_t partPdgC[] = { 211, 11, 2212}; Int_t chosenPart = 0; TString outDir = "./"; // Output file name TString outFile; if ( fileId == 0 ) outFile = Form("%s/pixel_%s.mc.root", outDir.Data(), mcEngine.Data()); else outFile = Form("%s/pixel_%s.mc.f%d.root", outDir.Data(), mcEngine.Data(), fileId); // Parameter file name TString parFile = Form("%s/pixel_%s.params.root", outDir.Data(), mcEngine.Data()); // In general, the following parts need not be touched // ======================================================================== // ---- Debug option ------------------------------------------------- gDebug = 0; // ------------------------------------------------------------------------ // ----- Timer -------------------------------------------------------- TStopwatch timer; timer.Start(); // ------------------------------------------------------------------------ // ----- Create simulation run ---------------------------------------- FairRunSim* run = new FairRunSim(); run->SetName(mcEngine); // Transport engine run->SetOutputFile(outFile); // Output file FairRuntimeDb* rtdb = run->GetRuntimeDb(); // ------------------------------------------------------------------------ // ----- Create media ------------------------------------------------- run->SetMaterials("media.geo"); // Materials // ------------------------------------------------------------------------ // ----- Create geometry ---------------------------------------------- FairModule* cave= new FairCave("CAVE"); cave->SetGeometryFileName("cave_vacuum.geo"); run->AddModule(cave); Pixel* det = new Pixel("Tut9", kTRUE); det->SetGeometryFileName("pixel.geo"); // det->SetMisalignDetector(kTRUE); run->AddModule(det); // ------------------------------------------------------------------------ // ----- Create PrimaryGenerator -------------------------------------- FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); FairBoxGenerator* boxGen = new FairBoxGenerator(partPdgC[chosenPart], 5); boxGen->SetPRange(1,2); boxGen->SetThetaRange(0,40); boxGen->SetPhiRange(0,360); // boxGen->SetDebug(kTRUE); primGen->AddGenerator(boxGen); run->SetGenerator(primGen); // ------------------------------------------------------------------------ run->SetStoreTraj(kFALSE); // ----- Initialize simulation run ------------------------------------ run->Init(); // ------------------------------------------------------------------------ // ----- Runtime database --------------------------------------------- Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFile.Data()); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ------------------------------------------------------------------------ // ----- Start run ---------------------------------------------------- run->Run(nEvents); run->CreateGeometryFile("geofile_full.root"); // ------------------------------------------------------------------------ // ----- Finish ------------------------------------------------------- cout << endl << endl; // Extract the maximal used memory an add is as Dart measurement // This line is filtered by CTest and the value send to CDash FairSystemInfo sysInfo; Float_t maxMemory=sysInfo.GetMaxMemory(); cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">"; cout << maxMemory; cout << "</DartMeasurement>" << endl; timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); Float_t cpuUsage=ctime/rtime; cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">"; cout << cpuUsage; cout << "</DartMeasurement>" << endl; cout << endl << endl; cout << "Output file is " << outFile << endl; cout << "Parameter file is " << parFile << endl; cout << "Real time " << rtime << " s, CPU time " << ctime << "s" << endl << endl; cout << "Macro finished successfully." << endl; // ------------------------------------------------------------------------ }
void number_of_particles_leaving_GEM_hits_boxgen(TString pre="", int nevts=0, double mom=4.1){ TDatabasePDG::Instance()-> AddParticle("pbarpSystem","pbarpSystem", 1.9, kFALSE, 0.1, 0,"", 88888); TStopwatch timer; if (pre==""){ //Output File TString OutputFile = "test_analysis_output.root"; TString outPath = ""; //Input simulation Files TString inPIDFile = "pid_complete.root"; TString inParFile = "simparams.root"; } else { //Output File TString outPath = pre + "_"; TString OutputFile = pre + "_test_analysis_output.root"; //Input simulation Files TString inPIDFile = pre + "_pid_complete.root"; TString inParFile = pre + "_simparams.root"; } TString PIDParFile = TString( gSystem->Getenv("VMCWORKDIR")) + "/macro/params/all.par"; //Initialization FairLogger::GetLogger()->SetLogToFile(kFALSE); FairRunAna* RunAna = new FairRunAna(); FairRuntimeDb* rtdb = RunAna->GetRuntimeDb(); RunAna->SetInputFile(inPIDFile); //setup parameter database FairParRootFileIo* parIo = new FairParRootFileIo(); parIo->open(inParFile); FairParAsciiFileIo* parIoPID = new FairParAsciiFileIo(); parIoPID->open(PIDParFile.Data(),"in"); rtdb->setFirstInput(parIo); rtdb->setSecondInput(parIoPID); rtdb->setOutput(parIo); RunAna->SetOutputFile(OutputFile); RunAna->Init(); /************************************************************************* * Create new ntuple and fill them with information ************************************************************************/ //*** create tuples RhoTuple * ntpPiMinus = new RhoTuple("ntpPiMinus", "PiMinus info"); RhoTuple * ntpPiPlus = new RhoTuple("ntpPiPlus", "PiPlus info"); RhoTuple * ntpKaonMinus = new RhoTuple("ntpKaonMinus", "KaonMinus info"); RhoTuple * ntpKaonPlus = new RhoTuple("ntpKaonPlus", "KaonPlus info"); RhoTuple * ntpProton = new RhoTuple("ntpProton", "Proton info"); RhoTuple * ntpAntiProton = new RhoTuple("ntpAntiProton", "Antiproton info"); //Create output file TFile *out = TFile::Open(outPath+"test_output_ana.root","RECREATE"); // data reader Object PndAnalysis* theAnalysis = new PndAnalysis(); if (nevts==0) nevts = theAnalysis->GetEntries(); //RhoCandLists for analysis RhoCandList piplus, piminus, proton, antiproton, kaonminus, kaonplus; RhoCandidate * dummyCand = new RhoCandidate(); //dummy candidate for empty candidate usage double p_m0 = TDatabasePDG::Instance()->GetParticle("proton")->Mass(); TLorentzVector ini (0,0, mom, sqrt(p_m0*p_m0+ mom*mom)+p_m0); TVector3 beamBoost = ini.BoostVector(); PndRhoTupleQA qa(theAnalysis, mom); int evt=-1; while (theAnalysis->GetEvent() && ++evt<nevts){ if ((evt%100)==0) cout << "evt "<< evt <<endl; TString PidSelection = "PidAlgoIdealCharged";//"PidAlgoMvd;PidAlgoStt;PidAlgoDrc"; to change from ideal PID to realistic PID uncomment this! //***Selection with no PID info theAnalysis->FillList(piminus, "PionBestMinus", PidSelection); theAnalysis->FillList(piplus, "PionBestPlus", PidSelection); theAnalysis->FillList(kaonminus, "KaonBestMinus", PidSelection); theAnalysis->FillList(kaonplus, "KaonBestPlus", PidSelection); theAnalysis->FillList(proton, "ProtonBestPlus", PidSelection); theAnalysis->FillList(antiproton, "ProtonBestMinus", PidSelection); //Get piminus information ntpPiMinus->Column("ev", (Float_t) evt); for (int j=0; j<piminus.GetLength(); ++j){ //information about the mother and MCTruth Candidate TLorentzVector l; float costheta = -999.; RhoCandidate * truth = piminus[j]->GetMcTruth(); RhoCandidate * mother; if (truth) mother = truth->TheMother(); int moth = (mother==0x0) ? 88888 : mother->PdgCode(); ntpPiMinus->Column("Mother", (Int_t) moth); bool truthmatch = theAnalysis->McTruthMatch(piminus[j]); ntpPiMinus->Column("MCTruthMatch", (bool) truthmatch); int gemhit = GemHits(piminus[j]); int count = 0; if (moth==88888 && gemhit==1 && truthmatch==1) count=1; ntpPiMinus->Column("GemHit", (int) count, 0); } ntpPiMinus->DumpData(); //Get PiPlus information ntpPiPlus->Column("ev", (int) evt); for (int j=0; j<piplus.GetLength(); ++j){ //information about the mother and MCTruth Candidate TLorentzVector l; float costheta = -999.; RhoCandidate * truth = piplus[j]->GetMcTruth(); RhoCandidate * mother; if (truth) mother = truth->TheMother(); int moth = (mother==0x0) ? 88888 : mother->PdgCode(); ntpPiPlus->Column("Mother", (Int_t) moth); bool truthmatch = theAnalysis->McTruthMatch(piplus[j]); ntpPiPlus->Column("MCTruthMatch", (bool) truthmatch); int gemhit = GemHits(piplus[j]); int count = 0; if (moth==88888 && gemhit==1 && truthmatch==1) count=1; ntpPiPlus->Column("GemHit", (int) count, 0); } ntpPiPlus->DumpData(); ntpKaonMinus->Column("ev", (int) evt); for (int j=0; j<kaonminus.GetLength(); ++j){ //information about the mother and MCTruth Candidate TLorentzVector l; float costheta = -999.; RhoCandidate * truth = kaonminus[j]->GetMcTruth(); RhoCandidate * mother; if (truth) mother = truth->TheMother(); int moth = (mother==0x0) ? 88888 : mother->PdgCode(); ntpKaonMinus->Column("Mother", (Int_t) moth); bool truthmatch = theAnalysis->McTruthMatch(kaonminus[j]); ntpKaonMinus->Column("MCTruthMatch", (bool) truthmatch); int gemhit = GemHits(kaonminus[j]); int count = 0; if (moth==88888 && gemhit==1 && truthmatch==1) count=1; ntpKaonMinus->Column("GemHit", (int) count, 0); } ntpKaonMinus->DumpData(); ntpKaonPlus->Column("ev", (int) evt); for (int j=0; j<kaonplus.GetLength(); ++j){ //information about the mother and MCTruth Candidate TLorentzVector l; float costheta = -999.; RhoCandidate * truth = kaonplus[j]->GetMcTruth(); RhoCandidate * mother; if (truth) mother = truth->TheMother(); int moth = (mother==0x0) ? 88888 : mother->PdgCode(); ntpKaonPlus->Column("Mother", (Int_t) moth); bool truthmatch = theAnalysis->McTruthMatch(kaonplus[j]); ntpKaonPlus->Column("MCTruthMatch", (bool) truthmatch); int gemhit = GemHits(kaonplus[j]); int count = 0; if (moth==88888 && gemhit==1 && truthmatch==1) count=1; ntpKaonPlus->Column("GemHit", (int) count, 0); } ntpKaonPlus->DumpData(); // Get Proton information ntpProton->Column("ev", (int) evt); for (int j=0; j<proton.GetLength(); ++j){ //information about the mother and MCTruth Candidate TLorentzVector l; float costheta = -999.; RhoCandidate * truth = proton[j]->GetMcTruth(); RhoCandidate * mother; if (truth) mother = truth->TheMother(); int moth = (mother==0x0) ? 88888 : mother->PdgCode(); ntpProton->Column("Mother", (Int_t) moth); bool truthmatch = theAnalysis->McTruthMatch(proton[j]); ntpProton->Column("MCTruthMatch", (bool) truthmatch); int gemhit = GemHits(proton[j]); int count = 0; if (moth==88888 && gemhit==1 && truthmatch==1) count=1; ntpProton->Column("GemHit", (int) count, 0); } ntpProton->DumpData(); // Get Antiproton ntpAntiProton->Column("ev", (int) evt); for (int j=0; j<antiproton.GetLength(); ++j){ //information about the mother and MCTruth Candidate TLorentzVector l; float costheta = -999.; RhoCandidate * truth = antiproton[j]->GetMcTruth(); RhoCandidate * mother; if (truth) mother = truth->TheMother(); int moth = (mother==0x0) ? 88888 : mother->PdgCode(); ntpAntiProton->Column("Mother", (Int_t) moth); bool truthmatch = theAnalysis->McTruthMatch(antiproton[j]); ntpAntiProton->Column("MCTruthMatch", (bool) truthmatch); int gemhit = GemHits(antiproton[j]); int count = 0; if (moth==88888 && gemhit==1 && truthmatch==1) count=1; ntpAntiProton->Column("GemHit", (int) count, 0); } ntpAntiProton->DumpData(); } //Write output out->cd(); ntpPiMinus ->GetInternalTree()->Write(); ntpPiPlus->GetInternalTree()->Write(); ntpKaonMinus ->GetInternalTree()->Write(); ntpKaonPlus->GetInternalTree()->Write(); ntpProton->GetInternalTree()->Write(); ntpAntiProton->GetInternalTree()->Write(); out->Save(); timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout<<"Macro finisched successfully."<<endl; cout<<"Realtime: "<<rtime<<" s, CPU time: "<<ctime<<" s"<<endl; cout<<endl; exit(0); }
void sim(Int_t file_nr=0, Int_t nEvents=1, Int_t s=0, Int_t seed=1){ Char_t filenr[4]; sprintf(filenr,"%04d",file_nr); printf("Filenr: %s\n", filenr); TString signal; if (s!=3312 && s!=3334) signal = "la"; else if (s==3312) signal = "xi"; else if (s==3334) signal = "om"; // ----- Paths and file names -------------------------------------------- TString inDir = gSystem->Getenv("URQMD_INPUT_PATH"); TString inFile = inDir + "/urqmd.auau.25gev.centr." + filenr + ".ftn14"; TString outDir= TString(filenr); outDir+= "/"; gSystem->mkdir(outDir.Data()); TString outFile = outDir+signal+".mc.root"; TString parFile = outDir+signal+".par.root"; // ----- Geometries ----------------------------------------------------- TString caveGeom = "cave.geo"; TString pipeGeom = "pipe_standard.geo"; TString targetGeom = "target_au_250mu.geo"; TString magnetGeom = "magnet_standard.geo"; TString stsGeom = "sts_Standard_s3055AAFK5.SecD.geo"; // ----- Magnetic field ----------------------------------------------- TString fieldMap = "FieldMuonMagnet"; // name of field map Double_t fieldZ = 50.; // field centre z position Double_t fieldScale = 1.; // field scaling factor gDebug = 0; gRandom->SetSeed(seed); // ---- Load libraries ------------------------------------------------- cout << endl << "=== much_sim.C : Loading libraries ..." << endl; gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C"); basiclibs(); gROOT->LoadMacro("$VMCWORKDIR/analysis/hyperon/analysislibs.C"); analysislibs(); FairRunSim* fRun = new FairRunSim(); fRun->SetName("TGeant3"); fRun->SetOutputFile(outFile.Data()); FairRuntimeDb* rtdb = fRun->GetRuntimeDb(); fRun->SetMaterials("media.geo"); // ----- Create detectors and passive volumes ------------------------- cout << endl << "=== much_sim.C : Create geeometry ..." << endl; if ( caveGeom != "" ) { FairModule* cave = new CbmCave("CAVE"); cave->SetGeometryFileName(caveGeom); fRun->AddModule(cave); cout << " --- " << caveGeom << endl; } if ( pipeGeom != "" ) { FairModule* pipe = new CbmPipe("PIPE"); pipe->SetGeometryFileName(pipeGeom); fRun->AddModule(pipe); cout << " --- " << pipeGeom << endl; } if ( targetGeom != "" ) { FairModule* target = new CbmTarget("Target"); target->SetGeometryFileName(targetGeom); fRun->AddModule(target); cout << " --- " << targetGeom << endl; } if ( magnetGeom != "" ) { FairModule* magnet = new CbmMagnet("MAGNET"); magnet->SetGeometryFileName(magnetGeom); fRun->AddModule(magnet); cout << " --- " << magnetGeom << endl; } if ( stsGeom != "" ) { FairDetector* sts = new CbmSts("STS", kTRUE); sts->SetGeometryFileName(stsGeom); cout << " --- " << stsGeom << endl; fRun->AddModule(sts); } // ----- Create magnetic field ---------------------------------------- cout << endl << "=== much_sim.C : Create magnetic field ..." << endl; CbmFieldMap* magField = NULL; if ( fieldMap == "FieldActive" || fieldMap == "FieldIron") magField = new CbmFieldMapSym3(fieldMap); else if ( fieldMap == "FieldAlligator" ) magField = new CbmFieldMapSym2(fieldMap); else if ( fieldMap == "FieldMuonMagnet" ) magField = new CbmFieldMapSym3(fieldMap); else { cout << "===> ERROR: Field map " << fieldMap << " unknown! " << endl; exit; } magField->SetPosition(0., 0., fieldZ); magField->SetScale(fieldScale); fRun->SetField(magField); // ----- Create PrimaryGenerator -------------------------------------- cout << endl << "=== much_sim.C : Create generators ..." << endl; FairPrimaryGenerator* primGen = new FairPrimaryGenerator(); if (signal=="om"){ delete gRandom; gRandom = new TRandom3(); CbmAnaHypYPtGenerator* gen = new CbmAnaHypYPtGenerator(3334); gen->SetDistributionPt(0.1603); // 6 GeV gen->SetDistributionY(1.277,0.412); // 6 GeV //gen->SetDistributionPt(0.149808); // 25 GeV //gen->SetDistributionY(1.9875,0.546669); // 25 GeV gen->Init(); primGen->AddGenerator(gen); } else if (signal=="xi"){ delete gRandom; gRandom = new TRandom3(); CbmAnaHypYPtGenerator* gen = new CbmAnaHypYPtGenerator(3312); gen->SetDistributionPt(0.1603); // 6 GeV gen->SetDistributionY(1.277,0.412); // 6 GeV //gen->SetDistributionPt(0.154319); // 25 GeV //gen->SetDistributionY(1.98604,0.617173); // 25 GeV gen->Init(); primGen->AddGenerator(gen); } FairUrqmdGenerator* urqmdGen = new FairUrqmdGenerator(inFile.Data()); primGen->AddGenerator(urqmdGen); fRun->SetGenerator(primGen); // ------------------------------------------------------------------------ fRun->Init(); // ------------------------------------------------------------------------ CbmFieldPar* fieldPar = (CbmFieldPar*) rtdb->getContainer("CbmFieldPar"); fieldPar->SetParameters(magField); fieldPar->setChanged(); fieldPar->setInputVersion(fRun->GetRunId(),1); Bool_t kParameterMerged = kTRUE; FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged); parOut->open(parFile); rtdb->setOutput(parOut); rtdb->saveOutput(); rtdb->print(); // ------------------------------------------------------------------------ TStopwatch timer; timer.Start(); fRun->Run(nEvents); // ----- Finish ------------------------------------------------------- timer.Stop(); Double_t rtime = timer.RealTime(); Double_t ctime = timer.CpuTime(); cout << endl << endl; cout << "=== sim.C : Macro finished successfully." << endl; cout << "=== sim.C : Output file is " << outFile << endl; cout << "=== sim.C : Real time used: " << rtime << "s " << endl; cout << "=== sim.C : CPU time used : " << ctime << "s " << endl; cout << endl << endl; // ------------------------------------------------------------------------ }
void comparison_cov_firstpar(int nevts=0, TString Path=""){ TDatabasePDG::Instance()-> AddParticle("pbarpSystem","pbarpSystem", 1.9, kFALSE, 0.1, 0,"", 88888); TStopwatch timer; //Output File TString outPath = Path; TString OutputFile = "cov_output.root"; //Input simulation Files TString DigiFile = Path + "digi_complete.root"; TString RecoFile = Path + "reco_complete.root"; TString inPIDFile = Path + "pid_complete.root"; TString inParFile = Path + "simparams.root"; TString PIDParFile = TString( gSystem->Getenv("VMCWORKDIR")) + "/macro/params/all.par"; //Initialization FairLogger::GetLogger()->SetLogToFile(kFALSE); FairRunAna* RunAna = new FairRunAna(); FairRuntimeDb* rtdb = RunAna->GetRuntimeDb(); RunAna->SetInputFile(inPIDFile); //setup parameter database FairParRootFileIo* parIo = new FairParRootFileIo(); parIo->open(inParFile); FairParAsciiFileIo* parIoPID = new FairParAsciiFileIo(); parIoPID->open(PIDParFile.Data(),"in"); rtdb->setFirstInput(parIo); rtdb->setSecondInput(parIoPID); rtdb->setOutput(parIo); RunAna->AddFriend(DigiFile); RunAna->AddFriend(RecoFile); RunAna->SetOutputFile(OutputFile); RunAna->Init(); // data reader Object PndAnalysis* theAnalysis = new PndAnalysis(); if (nevts==0) nevts = theAnalysis->GetEntries(); RhoCandList piminus, proton; TMatrixD CovPion(5,5); TMatrixD CovProton(5,5); int evt=-1; while (theAnalysis->GetEvent() && ++evt<nevts){ cout << "evt: " << evt << endl; TString PidSelection = "PidAlgoIdealCharged";//"PidAlgoMvd;PidAlgoStt;PidAlgoDrc"; //***Selection with no PID info theAnalysis->FillList(piminus, "PionAllMinus", PidSelection); theAnalysis->FillList(proton, "ProtonAllPlus", PidSelection); //Get piminus for (int j=0; j<piminus.GetLength(); ++j){ bool truth = theAnalysis->McTruthMatch(piminus[j]); if(truth){ TMatrixD piCov(7,7); piCov = piminus[j]->Cov7(); FairTrackParP paramFirst = theAnalysis->GetFirstPar(piminus[j]); double cov[15]; paramFirst.GetCov(cov); for (int i=0; i<15; i++){ if(TMath::Abs(cov[i]<1e-6)) cov[i]=0; } CovPion[0][0] = cov[0]; CovPion[0][1] = cov[1]; CovPion[0][2] = cov[2]; CovPion[0][3] = cov[3]; CovPion[0][4] = cov[4]; CovPion[1][1] = cov[5]; CovPion[1][2] = cov[6]; CovPion[1][3] = cov[7]; CovPion[1][4] = cov[8]; CovPion[2][2] = cov[9]; CovPion[2][3] = cov[10]; CovPion[2][4] = cov[11]; CovPion[3][3] = cov[12]; CovPion[3][4] = cov[13]; CovPion[4][4] = cov[14]; for (int i=0; i<5; i++){ for(int j=0; j<5; j++){ CovPion[j][i]=CovPion[i][j]; } } cout << "Covariance matrix for pion: " << endl; for(int i=0; i<7; i++){ for(int j=0; j<7; j++){ if(TMath::Abs(piCov[i][j])<1e-6) piCov[i][j]=0; } } piCov.Print(); cout << "First Par Covariance matrix for pion: " << endl; CovPion.Print(); } //Get proton for (int j=0; j<proton.GetLength(); ++j){ bool truth = theAnalysis->McTruthMatch(proton[j]); if(truth){ TMatrixD protCov = proton[j]->Cov7(); FairTrackParP paramFirst = theAnalysis->GetFirstPar(proton[j]); double cov[15]; paramFirst.GetCov(cov); for (int i=0; i<15; i++){ if(TMath::Abs(cov[i]<1e-6)) cov[i]=0; } CovProton[0][0] = cov[0]; CovProton[0][1] = cov[1]; CovProton[0][2] = cov[2]; CovProton[0][3] = cov[3]; CovProton[0][4] = cov[4]; CovProton[1][1] = cov[5]; CovProton[1][2] = cov[6]; CovProton[1][3] = cov[7]; CovProton[1][4] = cov[8]; CovProton[2][2] = cov[9]; CovProton[2][3] = cov[10]; CovProton[2][4] = cov[11]; CovProton[3][3] = cov[12]; CovProton[3][4] = cov[13]; CovProton[4][4] = cov[14]; for (int i=0; i<5; i++){ for(int j=0; j<5; j++){ CovProton[j][i]=CovProton[i][j]; } } cout << "Covariance matrix for proton: " << endl; for(int i=0; i<7; i++){ for(int j=0; j<7; j++){ if(TMath::Abs(protCov[i][j])<1e-6) protCov[i][j]=0; } } protCov.Print(); cout << "First Par Covariance matrix for proton: " << endl; CovProton.Print(); } } } } }