CHEWING_API int chewing_Init( const char *dataPath, const char *hashPath ) { /* initialize Tree, Char, and Dict */ /* FIXME: check the validation of dataPath */ InitTree( dataPath ); InitChar( dataPath ); InitDict( dataPath ); /* initialize Hash */ /* FIXME: check the validation of hashPath */ InitHash( hashPath ); /* initialize SymbolTable */ if ( ! InitSymbolTable( (char*) hashPath ) ) InitSymbolTable( (char*) dataPath ); if ( ! InitEasySymbolInput( (char *) hashPath ) ) InitEasySymbolInput( (char *) dataPath ); /* initialize HanyuPinYin table */ if ( ! InitHanyuPinYin( hashPath ) ) InitHanyuPinYin( dataPath ); #ifdef ENABLE_DEBUG { char *dbg_path; int failsafe = 1; dbg_path = getenv( "CHEWING_DEBUG" ); if ( dbg_path ) { fp_g = fopen( dbg_path, "w+" ); if ( fp_g ) failsafe = 0; } if ( failsafe == 1 ) { dbg_path = FAILSAFE_OUTPUT; fp_g = fopen( dbg_path, "w+" ); if ( ! fp_g ) { fprintf( stderr, "Failed to record debug message in file.\n" "--> Output to stderr\n" ); } } /* register debug service */ if ( fp_g ) addTerminateService( TerminateDebug ); } #endif bTerminateCompleted = 0; return 0; }
void main() { int i; CSTree T,p,q; TElemType e,e1; InitTree(T); printf("构造空树后,树空否? %d(1:是 0:否) 树根为%c 树的深度为%d\n",TreeEmpty(T),Root(T),TreeDepth(T)); CreateTree(T); printf("构造树T后,树空否? %d(1:是 0:否) 树根为%c 树的深度为%d\n",TreeEmpty(T),Root(T),TreeDepth(T)); printf("先根遍历树T:\n"); PreOrderTraverse(T,vi); printf("\n请输入待修改的结点的值 新值: "); scanf("%c%*c%c%*c",&e,&e1); Assign(T,e,e1); printf("后根遍历修改后的树T:\n"); PostOrderTraverse(T,vi); printf("\n%c的双亲是%c,长子是%c,下一个兄弟是%c\n",e1,Parent(T,e1),LeftChild(T,e1),RightSibling(T,e1)); printf("建立树p:\n"); InitTree(p); CreateTree(p); printf("层序遍历树p:\n"); LevelOrderTraverse(p,vi); printf("\n将树p插到树T中,请输入T中p的双亲结点 子树序号: "); scanf("%c%d%*c",&e,&i); q=Point(T,e); InsertChild(T,q,i,p); printf("层序遍历树T:\n"); LevelOrderTraverse(T,vi); printf("\n删除树T中结点e的第i棵子树,请输入e i: "); scanf("%c%d",&e,&i); q=Point(T,e); DeleteChild(T,q,i); printf("层序遍历树T:\n",e,i); LevelOrderTraverse(T,vi); printf("\n"); DestroyTree(T); }
void unitTest() { TreeType tree = InitTree(); printf("After initlizing tree:\n"); PrintTree(tree); PositionType question = 0; PositionType answer = 5; printf("IsLeaf test 1: %s\n", IsLeaf(tree, question) ? "error" : "pass"); printf("IsLeaf test 2: %s\n", IsLeaf(tree, answer) ? "pass" : "error"); printf("Top test: %s\n", Top(tree) == 0 ? "pass" : "error"); printf("Question test 1: %s\n", strcmp(Question(tree, question), "Is it furry?") == 0 ? "pass" : "error"); printf("Question test 2: %s\n", strcmp(Question(tree, answer), "Is it a lizard?") == 0 ? "pass" : "error"); printf("%s\n", Question(tree, answer)); ReplaceNode(tree, 7, "a kitten", "Is it an adult?"); PrintTree(tree); }
/*----------*/ TTree *NewTree() { TTree *tree; if ( (tree=(TTree *)malloc(sizeof(TTree)))==NULL ) { strcpy(treeErrorMsg, "Out of memory creating tree."); return NULL; } memset(tree, 0, sizeof(TTree)); /* grj */ tree->capacity=0; CheckCapacity(tree, 1000); InitTree(tree); return tree; } /* NewTree */
BOOL CIfExpressEditorDlg::OnInitDialog() { CCxBCGPDialog::OnInitDialog(); ModifyStyle( WS_THICKFRAME, 0, SWP_FRAMECHANGED|SWP_DRAWFRAME ); // TODO: 在此添加额外的初始化 SetIcon(AfxGetApp()->LoadIcon(IDR_MAINFRAME), TRUE); // Set big icon if (!InitDlgCtrl()) { MessageBox("解析输入条件表达式失败!",g_lpszAppTitle,MB_OK|MB_ICONERROR); EndDialog(0); } InitTree(); return TRUE; // return TRUE unless you set the focus to a control // 异常: OCX 属性页应返回 FALSE }
void DlgCScenarioManager::OnCloneWithOutChild() { // TODO: Add your command handler code here HTREEITEM hItem = m_tree.GetSelectedItem(); if(hItem == NULL) return; DWORD key = m_tree.GetItemData(hItem); Scenario *pScenario = m_manager.LookUp(key); Scenario *pClone = m_manager.CloneWithOutChild(pScenario,DefaultName(pScenario)); if(pClone != NULL) { InitTree(pClone,m_tree.GetParentItem(hItem)); InitPage(); UpdateData(FALSE); } }
BOOL DlgCScenarioManager::OnInitDialog() { CDialog::OnInitDialog(); // TODO: Add extra initialization here m_tab.AddPage(IDS_STRSUMMARY, &m_page1, IDD_SUMMARY); m_tab.AddPage(IDS_STRDETAILS, &m_page2, IDD_DETAILS); m_tab.Show(); m_strCurScenario = m_manager.GetCurAncestName(); InitTree(m_manager.GetBaseScenario()); m_tree.SelectItem(m_tree.GetRootItem()); InitPage(); UpdateData(FALSE); return TRUE; // return TRUE unless you set the focus to a control // EXCEPTION: OCX Property Pages should return FALSE }
void DlgCScenarioManager::OnPromote() { // TODO: Add your command handler code here if(IDCANCEL ==AfxMessageBox(IDS_PROMOTESCENARIOMSG,MB_OKCANCEL)) return; HTREEITEM hItem = m_tree.GetSelectedItem(); if(hItem == NULL) return; DWORD key = m_tree.GetItemData(hItem); Scenario *pScenario = m_manager.LookUp(key); if(m_manager.Promote(pScenario)) { InitTree(pScenario,m_tree.GetParentItem(m_tree.GetParentItem(hItem))); m_tree.DeleteItem(hItem); } InitPage(); }
void main() { int i; CSTree T, p, q; TElemType e, e1; InitTree(T); printf("构造空树后,树空否?%d(1:是 0:否)。树根为%c,树的深度为%d。\n", TreeEmpty(T), Root(T), TreeDepth(T)); CreateTree(T); printf("构造树T后,树空否?%d(1:是 0:否)。树根为%c,树的深度为%d。\n", TreeEmpty(T), Root(T), TreeDepth(T)); printf("层序遍历树T:\n"); LevelOrderTraverse(T, visit); printf("请输入待修改的结点的值 新值:"); scanf("%c%*c%c%*c", &e, &e1); Assign(T, e, e1); printf("层序遍历修改后的树T:\n"); LevelOrderTraverse(T, visit); printf("%c的双亲是%c,长子是%c,下一个兄弟是%c。\n", e1, Parent(T, e1), LeftChild(T, e1), RightSibling(T, e1)); printf("建立树p:\n"); CreateTree(p); printf("层序遍历树p:\n"); LevelOrderTraverse(p, visit); printf("将树p插到树T中,请输入T中p的双亲结点 子树序号:"); scanf("%c%d%*c", &e, &i); q = Point(T, e); InsertChild(T, q, i, p); printf("层序遍历修改后的树T:\n"); LevelOrderTraverse(T, visit); printf("先根遍历树T:\n"); PreOrderTraverse(T, visit); printf("\n后根遍历树T:\n"); PostOrderTraverse(T, visit); printf("\n删除树T中结点e的第i棵子树,请输入e i:"); scanf("%c%d", &e, &i); q = Point(T, e); DeleteChild(T, q, i); printf("层序遍历修改后的树T:\n"); LevelOrderTraverse(T, visit); DestroyTree(T); }
DirectoryTree::DirectoryTree ( wxWindow * wndParent, const wxWindowID id, const wxPoint& pntPosition, const wxSize& siz, long nStyle ) : wxTreeCtrl(wndParent, id, pntPosition, siz, nStyle), m_wndParent(wndParent), m_imlButtons(9, 9, true), m_iml(16, 16, true), m_bShowHidden(false) { wxASSERT_MSG(wndParent != 0, wxT("DirectoryTree::DirectoryTree() 'wndParent' == 0.")); wxASSERT_MSG(res, wxT("DirectoryTree::DirectoryTree() 'res' not loaded.")); // TBI: work around wx's silly behaviour of showing a different icon when // the tree item is expanded // wx works as follows: one item for unselected (expanded or not) and selected open, // another for selected closed // It sounds logical, but it's actually silly: // showing 'openness' is what buttons, not icons, are for. // We want a different selected icon wxBitmap bmpFolderClosed = res->GetImage(resFolderNormal); m_iml.Add(bmpFolderClosed); m_iml.Add(bmpFolderClosed); // FIXME: why is this not in the msw version? #ifdef _GENERIC_TREECTRL_H_ wxBitmap bmpPlus = res->GetImage(resButtonPlus); wxBitmap bmpMinus = res->GetImage(resButtonMinus); m_imlButtons.Add(bmpPlus); // Unselected closed button m_imlButtons.Add(bmpPlus); // Selected closed button m_imlButtons.Add(bmpMinus); // Unselected open button m_imlButtons.Add(bmpMinus); // Selected open button SetButtonsImageList(&m_imlButtons); #endif // def __UNIX__ SetImageList(&m_iml); InitTree(); }
KDPhotonsTree::KDPhotonsTree(Photons* toAdd) { DWORD startTime = timeGetTime(); size_t curNumberOfThreads = GLOBAL_PROPERTIES::numberOfThreads; m_logOfNumberOfThreads = 0; while(curNumberOfThreads>>=1) ++m_logOfNumberOfThreads; size_t n = toAdd->size(); if(!n) throw Error("Empty photon vector"); GLOBAL_PROPERTIES::numberOfProcessedPhotons += n; for(int i = 1 ; ; ++i) { n >>= i; if(!n) { n = 1 << i; break; } n <<= i; } m_numberOfPhotons = n; m_treeArray = new TreeElement[m_numberOfPhotons]; InitTree(*toAdd, 1, toAdd->begin(), toAdd->end(), 0); m_photonsHeaps = new MaxHeap[GLOBAL_PROPERTIES::numberOfThreads]; std::cout << "Photons KDtree build was over in " << (timeGetTime() - startTime) << " ms" << std::endl; delete toAdd; }
void CPageDocuments::Initialize() { // m_list.SetExtendedStyle(LVS_EX_FULLROWSELECT); CreateImageList(); InitTree(); }
CHEWING_API ChewingContext *chewing_new() { ChewingContext *ctx; int ret; char search_path[PATH_MAX]; char path[PATH_MAX]; ctx = ALC( ChewingContext, 1 ); if ( !ctx ) goto error; ctx->output = ALC ( ChewingOutput, 1 ); if ( !ctx->output ) goto error; ctx->data = allocate_ChewingData(); if ( !ctx->data ) goto error; chewing_Reset( ctx ); ret = get_search_path( search_path, sizeof( search_path ) ); if ( ret ) goto error; ret = find_path_by_files( search_path, DICT_FILES, path, sizeof( path ) ); if ( ret ) goto error; ret = InitDict( ctx->data, path ); if ( ret ) goto error; ret = InitTree( ctx->data, path ); if ( ret ) goto error; ret = InitHash( ctx->data ); if ( !ret ) goto error; ctx->cand_no = 0; ret = find_path_by_files( search_path, SYMBOL_TABLE_FILES, path, sizeof( path ) ); if ( ret ) goto error; ret = InitSymbolTable( ctx->data, path ); if ( ret ) goto error; ret = find_path_by_files( search_path, EASY_SYMBOL_FILES, path, sizeof( path ) ); if ( ret ) goto error; ret = InitEasySymbolInput( ctx->data, path ); if ( ret ) goto error; ret = find_path_by_files( search_path, PINYIN_FILES, path, sizeof( path ) ); if ( ret ) goto error; ret = InitPinyin( ctx->data, path ); if ( !ret ) goto error; return ctx; error: chewing_delete( ctx ); return NULL; }
void Encode() { int i,c,len,r,s,lml,cbp; unsigned char codebuf[17],mask; InitTree(); codebuf[0]=0; cbp=mask=1; s=0; r=N-F; memset(buffer,' ',r); for( len=0; len<F && (c = GetByte()) != EOF; len++ ) buffer[r+len]=c; if(len==0) return; for(i=1;i<=F;i++) InsertNode(r-i); InsertNode(r); do { if(mlen>len) mlen=len; if(mlen<=THRESHOLD) { mlen=1; codebuf[0]|=mask; codebuf[cbp++]=buffer[r]; } else { codebuf[cbp++]=(unsigned char)mpos; codebuf[cbp++]=(unsigned char)(((mpos>>4)&0xF0)|(mlen-(THRESHOLD+1))); } if((mask<<=1)==0) { for(i=0;i<cbp;i++) PutByte(codebuf[i]); codebuf[0]=0; cbp=mask=1; } lml=mlen; for(i=0;i<lml&&(c=GetByte())!=EOF;i++) { DeleteNode(s); buffer[s]=c; if(s<F-1) buffer[s+N]=c; s=(s+1)&(N-1); r=(r+1)&(N-1); InsertNode(r); } while(i++<lml) { DeleteNode(s); s=(s+1)&(N-1); r=(r+1)&(N-1); if(--len) InsertNode(r); } }while(len>0); if(cbp>1) for(i=0;i<cbp;i++) PutByte(codebuf[i]); }
void KDPhotonsTree::InitTree(const Photons &photons, const size_t index, const Photons::iterator begin, const Photons::iterator end, const size_t depth) { const size_t dist_it = end - begin; if(dist_it < 0) { throw Error("initializing KD tree error"); } if(dist_it < 1) { if(index < m_numberOfPhotons && begin != photons.end())m_treeArray[index] = TreeElement(*begin, ST_NON_EXIST); return; } if(dist_it == 1) { if(index < m_numberOfPhotons)m_treeArray[index] = TreeElement(*begin, ST_LEAF); return; } Point min( GLOBAL_PROPERTIES::INFINITY, GLOBAL_PROPERTIES::INFINITY, GLOBAL_PROPERTIES::INFINITY); Point max(-GLOBAL_PROPERTIES::INFINITY, -GLOBAL_PROPERTIES::INFINITY, -GLOBAL_PROPERTIES::INFINITY); for(Photons::iterator it = begin; it != end; it++) { if(it->position.x() < min.x()) min.x(it->position.x()); if(it->position.y() < min.y()) min.y(it->position.y()); if(it->position.z() < min.z()) min.z(it->position.z()); if(it->position.x() > max.x()) max.x(it->position.x()); if(it->position.y() > max.y()) max.y(it->position.y()); if(it->position.z() > max.z()) max.z(it->position.z()); } Point distPoint = max - min; Split_type split = (distPoint.x() >= distPoint.y() && distPoint.x() >= distPoint.z()) ? ST_X_COORD : ( (distPoint.y() >= distPoint.z()) ? ST_Y_COORD : ST_Z_COORD ); std::sort(begin, end, split == ST_X_COORD ? x_comp_func : (split == ST_Y_COORD ? y_comp_func : z_comp_func) ); const Photons::iterator middle = begin + ((end - begin)/2); if(((index << 1) | 1) < m_numberOfPhotons) { m_treeArray[index] = TreeElement(*middle, split); if(depth < m_logOfNumberOfThreads) { // Need to split to two threads (create extra one) ///////////////////////////////////////////////////////////// // parallelization ///////////////////////////////////////////////////////////// DWORD tID; HANDLE handle; PhotonsTreeBuildThreadArguments *arguments = new PhotonsTreeBuildThreadArguments(*this, photons, (index << 1), begin, middle, depth+1); handle = CreateThread( NULL, 0, ThreadBuildFunc, (LPVOID)arguments, 0, &tID); ///////////////////////////////////////////////////////////// // Complete second part of tree itself InitTree(photons, (index << 1) | 1, middle+1, end , depth+1); // wait for sibling thread to finish his work WaitForSingleObject(handle, INFINITE); } else { InitTree(photons, (index << 1) , begin , middle, depth+1); InitTree(photons, (index << 1) | 1, middle+1, end , depth+1); } } else { m_treeArray[index] = TreeElement(*middle, ST_LEAF); } }
void SWCompress_RW(SWCompressPtr state, SDL_RWops *in, SDL_RWops *out) { int i, c, len, r, s, last_match_length, code_buf_ptr; unsigned char mask; InitTree(state); /* initialize trees */ state->code_buf[0] = 0; code_buf_ptr = mask = 1; s = 0; r = N - F; for (i = s; i < r; i++) { state->text_buf[i] = OFTEN; /* Clear the buffer with any character that will appear often. */ } for (len = 0; len < F && (c = SDL_getc(in)) != EOF; len++ ) { state->text_buf[r + len] = c; /* Read F bytes into the last F bytes of the buffer */ } state->textsize = len; if (state->textsize == 0) return; /* text of size zero */ for (i = 1; i <= F; i++) InsertNode(state, r - i); /* Insert the F strings, each of which begins with one or more 'space' characters. Note the order in which these strings are inserted. This way, degenerate trees will be less likely to occur. */ InsertNode(state, r); /* Finally, insert the whole string just read. The global variables match_length and match_position are set. */ do { if (state->match_length > len) state->match_length = len; /* match_length may be spuriously long near the end of text. */ if (state->match_length <= THRESHOLD) { state->match_length = 1; /* Not long enough match. Send one byte. */ state->code_buf[0] |= mask; /* 'send one byte' flag */ state->code_buf[code_buf_ptr++] = state->text_buf[r]; /* Send uncoded. */ } else { state->code_buf[code_buf_ptr++] = (unsigned char) state->match_position; state->code_buf[code_buf_ptr++] = (unsigned char) (((state->match_position >> 4) & 0xf0) | (state->match_length - (THRESHOLD + 1))); /* Send position and length pair. Note match_length > THRESHOLD. */ } if ((mask <<= 1) == 0) { /* Shift mask left one bit. */ for (i = 0; i < code_buf_ptr; i++) /* Send at most 8 units of */ { SDL_putc(state->code_buf[i],out); /* code together */ } state->codesize += code_buf_ptr; state->code_buf[0] = 0; code_buf_ptr = mask = 1; } last_match_length = state->match_length; for (i = 0; i < last_match_length && (c = SDL_getc(in)) != EOF; i++ ) { DeleteNode(state, s); /* Delete old strings and */ state->text_buf[s] = c; /* read new bytes */ if (s < F - 1) state->text_buf[s + N] = c; /* If the position is near the end of buffer, extend the buffer to make string comparison easier. */ s = (s + 1) & (N - 1); r = (r + 1) & (N - 1); /* Since this is a ring buffer, increment the position modulo N. */ InsertNode(state, r); /* Register the string in text_buf[r..r+F-1] */ } while (i++ < last_match_length) { /* After the end of text, */ DeleteNode(state, s); /* no need to read, but */ s = (s + 1) & (N - 1); r = (r + 1) & (N - 1); if (--len) InsertNode(state, r); /* buffer may not be empty. */ } } while (len > 0); /* until length of string to be processed is zero */ if (code_buf_ptr > 1) { /* Send remaining code. */ for (i = 0; i < code_buf_ptr; i++) { SDL_putc(state->code_buf[i],out); } state->codesize += code_buf_ptr; } }
//*******MAIN******************************************************************* int main (int argc, char** argv) { std::cout<<"--------DUMPER TEMPLATE FIT: READ RAW DATA AND PRODUCE RECO TREE--------"<<std::endl; //-----this map tells how the MCPs will be order in the output tree. The names should match the cfg file---- Fill_MCPList(); //look into the MCPMap.h class //--------Read Options-------------------------------- ifstream inputCfg (argv[1], ios::in); std::string inputFolder = argv[2]; int nChannels = atoi (argv[3]); std::string outputFile = argv[4]; std::string ProMedioFile = argv[5]; TProfile** wf_promed = new TProfile*[10]; TH1F** templateHisto = new TH1F*[10]; double pro_medio_CF[10] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.}; double pro_medio_Charge[10] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.}; TFile* inF = TFile::Open(ProMedioFile.c_str(),"read"); for(int iCh=0; iCh<10; ++iCh) { wf_promed[iCh] = (TProfile*)inF->Get(Form("wf_promed_%d",iCh)); wf_promed[iCh]->SetDirectory(0); } inF->Close(); inF->Delete(); for(int iCh=0; iCh<10; ++iCh) { templateHisto[iCh] = new TH1F(Form("templateHisto_%d",iCh), "", 1024, 0., 1024.); for(int iBins=1; iBins<=1024; ++iBins) { if(iBins <= 100) templateHisto[iCh]->SetBinContent(iBins, wf_promed[iCh]->GetBinContent(iBins+150)); else if(iBins > 100 && iBins < 250) templateHisto[iCh]->SetBinContent(iBins, templateHisto[iCh]->GetBinContent(iBins-100)); else templateHisto[iCh]->SetBinContent(iBins, wf_promed[iCh]->GetBinContent(iBins)); } double amp = 0.5; TimeConstFrac_ProMedio(templateHisto[iCh], amp, pro_medio_CF[iCh]); pro_medio_Charge[iCh] = templateHisto[iCh]->Integral(pro_medio_CF[iCh]-5, pro_medio_CF[iCh]+20); wf_promed[iCh]->Delete(); // std::cout << " iCh = " << iCh << " pro_medio_CF[iCh] = " << pro_medio_CF[iCh] << " pro_medio_Charge[iCh] = " << pro_medio_Charge[iCh] << std::endl; } // for(int iCh=0; iCh<10; ++iCh) std::cout << " templateHisto[iCh]->GetEntries() = " << templateHisto[iCh]->GetEntries() << std::endl; // return 500; //---------output tree---------------- TFile* outROOT = TFile::Open(("ntuples/reco_"+outputFile+".root").c_str(),"recreate"); outROOT->cd(); TTree* outTree = new TTree("reco_tree", "reco_tree"); outTree->SetDirectory(0); SetOutTree(outTree); int run=0, chNumber=0, HVtemp=0, PC=0; float X0temp=0.; std::string name, trig1, trig2; //---------definitions----------- std::map<int, int> PCOn; std::map<int, int> HVVal; std::map<int, std::string> MCPName; int start=0; //-------start to read the cfg file-------- while(!inputCfg.eof()) { PCOn.clear(); HVVal.clear(); MCPName.clear(); if (start==0) { //read trigger chambers inputCfg >> trig1 >> trig2; start=1; } //-----fill maps-------- for (int count=0; count<nChannels; count++) //read exactly nChannels lines of the cfg file -> be careful to give the right number in input!!!! { inputCfg >> run >> chNumber >> HVtemp >> X0temp >> PC >> name; PCOn.insert(std::make_pair(chNumber,PC)); HVVal.insert(std::make_pair(chNumber,HVtemp)); MCPName.insert(std::make_pair(chNumber,name)); } //-----Definitions vector<float> digiCh[10]; float timeCF[10], timeCFcorr[10]; float timeOT[10]; float timeMax[10]; float intBase[10], intSignal[10], intSignalcorr[10], ampMax[10]; ///int fibreX[8], hodoYchannels[8]; TH1F** wfHisto = new TH1F*[10]; TF1** f_templateFit = new TF1*[10]; //--reading wire chamber from other tree -- TChain* t1 = new TChain("outputTree"); InitTree2(t1); //---Chain TChain* chain = new TChain("H4tree"); InitTree(chain); char command1[300]; sprintf(command1, "find %s/%d/*/dqmPlotstotal.root > listTemp_%s_%d.txt", (inputFolder).c_str(), run, outputFile.c_str(), run); system(command1); char command2[300]; sprintf(command2, "find %s/%d/[0-9]*.root > listTemp2_%s_%d.txt", (inputFolder).c_str(), run, outputFile.c_str(), run); system(command2); char list1[200]; char list2[200]; sprintf (list1, "listTemp_%s_%d.txt", outputFile.c_str(), run); sprintf (list2, "listTemp2_%s_%d.txt", outputFile.c_str(), run); ifstream rootList (list1); ifstream rootList2 (list2); while (!rootList.eof() && !rootList2.eof()) { char iRun_tW[70]; rootList >> iRun_tW; char iRun_str[70]; rootList2 >> iRun_str; TChain* tTemp = new TChain("outputTree"); tTemp->Add(iRun_tW); TChain* tTempH4 = new TChain("H4tree"); tTempH4->Add(iRun_str); if (tTemp->GetEntries() == tTempH4->GetEntries()) { t1->Add(iRun_tW); chain->Add(iRun_str); } else std::cout<<"Bad spill found.. Skipped"<<std::endl; tTemp->Delete(); tTempH4->Delete(); } char command3[300]; sprintf(command3, "rm listTemp_%s_%d.txt", outputFile.c_str(), run); char command4[300]; sprintf(command4, "rm listTemp2_%s_%d.txt", outputFile.c_str(), run); system(command3); system(command4); std::cout<<"start reading run: "<<run<<std::endl; //-----Data loop-------------------------------------------------------- for(int iEntry=0; iEntry<chain->GetEntries(); iEntry++){ // for(int iEntry=7; iEntry<8; iEntry++){ //RA if(iEntry % 1000 == 0) cout << "read entry: " << iEntry << endl; //-----Unpack data-------------------------------------------------- for(int iCh=0; iCh<nChannels; iCh++) { digiCh[iCh].clear(); wfHisto[iCh] = new TH1F(Form("wfHisto_%d", iCh), "", 1024, 0., 1024.); } //---Read the entry chain->GetEntry(iEntry); unsigned int spill=spillNumber; unsigned int event=evtNumber; /* for(unsigned int iCh=0; iCh<nAdcChannels; iCh++) { if(adcBoard[iCh] == 1 && adcChannel[iCh] == 0) sci_front_adc = adcData[iCh]; if(adcBoard[iCh] == 1 && adcChannel[iCh] >= HODOX_ADC_START_CHANNEL && adcChannel[iCh] <= HODOX_ADC_END_CHANNEL) fibreX[(adcChannel[iCh]-HODOX_ADC_START_CHANNEL)] = adcData[iCh]; if(adcBoard[iCh] == 1 && adcChannel[iCh] >= HODOY_ADC_START_CHANNEL && adcChannel[iCh] <= HODOY_ADC_END_CHANNEL) fibreY[(adcChannel[iCh]-HODOY_ADC_START_CHANNEL)] = adcData[iCh]; } */ int tStart[10] = {0,0,0,0,0,0,0,0,0,0}; int tStop[10] = {0,0,0,0,0,0,0,0,0,0}; int tMax[10] = {0,0,0,0,0,0,0,0,0,0}; float aMax[10] = {10000., 10000., 10000., 10000., 10000., 10000., 10000., 10000., 10000., 10000.}; float bLine[10] = {0.,0.,0.,0.,0., 0.,0.,0.,0.,0.}; //---Read digitizer samples for(unsigned int iSample=0; iSample<nDigiSamples; iSample++){ if(iSample > 1024*10 - 1) break; if (digiGroup[iSample] == 1 && digiChannel[iSample] == 0){ digiCh[9].push_back(digiSampleValue[iSample]); wfHisto[9]->SetBinContent((iSample%1024) + 1, digiSampleValue[iSample]); int iBin = (iSample%1024) + 1; float value = digiSampleValue[iSample]; if((iBin >= 10 && iBin < 30) || (iBin >= 500 && iBin < 1000)) bLine[9] += value/520; // if(digiChannel[iSample] == 9) std::cout << " value = " << value << std::endl; if(value < aMax[9]) { aMax[9] = value; tMax[9] = iBin; } if(iBin > 50 && value < 500. && tStart[9] == 0) tStart[9] = iBin; if(iBin > 50 && value > 500. && tStart[9] != 0 && tStop[9] == 0) tStop[9] = iBin; } else{ digiCh[digiChannel[iSample]].push_back(digiSampleValue[iSample]); wfHisto[digiChannel[iSample]]->SetBinContent((iSample%1024) + 1, digiSampleValue[iSample]); int iBin = (iSample%1024) + 1; float value = digiSampleValue[iSample]; if((iBin >= 10 && iBin < 30) || (iBin >= 500 && iBin < 1000)) bLine[digiChannel[iSample]] += value/520; if(digiChannel[iSample] == 9) std::cout << " value = " << value << std::endl; if(value < aMax[digiChannel[iSample]]) { aMax[digiChannel[iSample]] = value; tMax[digiChannel[iSample]] = iBin;} if(iBin > 50 && value < 500. && tStart[digiChannel[iSample]] == 0) tStart[digiChannel[iSample]] = iBin; if(iBin > 50 && value > 500. && tStart[digiChannel[iSample]] != 0 && tStop[digiChannel[iSample]] == 0) tStop[digiChannel[iSample]] = iBin; } } //---loop over MPC's channels for(int iCh=0; iCh<nChannels; iCh++){ if(iCh < 4) continue; if(iCh == 8) continue; // std::cout << " loop over MCP iCh = " << iCh << std::endl; // std::cout << " bLine[iCh] = " << bLine[iCh] << std::endl; // std::cout << " aMax[iCh] = " << aMax[iCh] << std::endl; // std::cout << " tMax[iCh] = " << tMax[iCh] << std::endl; // std::cout << " tStart[iCh] = " << tStart[iCh] << std::endl; // std::cout << " tStop[iCh] = " << tStop[iCh] << std::endl; tMax[iCh] -= 300; double scale = 0.; double scaleErr = 0.; double baseL = 0.; double baseLErr = 0.; double xTime = 0.; double xTimeErr = 0.; FindTemplateFit(scale, scaleErr, baseL, baseLErr, xTime, xTimeErr, tStart[iCh], tStop[iCh], tMax[iCh], aMax[iCh], bLine[iCh], templateHisto[iCh], wfHisto[iCh], &(f_templateFit[iCh])); float par0 = f_templateFit[iCh]->GetParameter(0); float par1 = f_templateFit[iCh]->GetParameter(1); float par2 = f_templateFit[iCh]->GetParameter(2); float par3 = f_templateFit[iCh]->GetParameter(3); ampMax[iCh] = par0; //tMax timeMax[iCh] = (300. / par1) + par2; timeCF[iCh] = (pro_medio_CF[iCh] / par1) + par2; intSignal[iCh] = pro_medio_Charge[iCh] * par0/par1 + par3/par1 * 25; intBase[iCh] = par3; timeOT[iCh] = par2; intSignalcorr[iCh] = par1; timeCFcorr[iCh] = timeCF[iCh]; // std::cout << " >> timeMax[iCh] = " << timeMax[iCh] << std::endl; // std::cout << " >> timeCF[iCh] = " << timeCF[iCh] << std::endl; // std::cout << " >> f_templateFit[iCh]->GetParameter(0) = " << f_templateFit[iCh]->GetParameter(0) << std::endl; /* if(iCh == 4){ TCanvas* c1 = new TCanvas(); templateHisto[iCh]->Draw(); f_templateFit[iCh]->Draw("same"); c1->Print("pippo.png", "png"); TCanvas* c2 = new TCanvas(); wfHisto[iCh]->Draw(); f_templateFit[iCh]->Draw("same"); c2->Print("pippo2.png", "png"); TFile outFile_template("outFile_template.root", "recreate"); outFile_template.cd(); iCh = 4; templateHisto[iCh]->Write(Form("promedio_%d", iCh)); wfHisto[iCh]->Write(Form("wfHisto_%d", iCh)); f_templateFit[iCh]->Write(Form("func_%d", iCh)); outFile_template.Close(); } */ } /* TFile outFile_template("outFile_template.root", "recreate"); outFile_template.cd(); for(int iCh=0; iCh<nChannels; iCh++){ if(iCh < 4) continue; if(iCh == 8) continue; templateHisto[iCh]->Write(Form("promedio_%d", iCh)); wfHisto[iCh]->Write(Form("wfHisto_%d", iCh)); f_templateFit[iCh]->Write(Form("func_%d", iCh)); } outFile_template.Close(); return 100; */ //--------dump ntuple - impulses are negative, invert the sign for (int iCh=0; iCh<nChannels; iCh++) { time_CF[MCPList.at(MCPName.at(iCh))] = timeCF[iCh]; time_CF_corr[MCPList.at(MCPName.at(iCh))] = timeCFcorr[iCh]; time_OT[MCPList.at(MCPName.at(iCh))] = timeOT[iCh]; time_Max[MCPList.at(MCPName.at(iCh))] = timeMax[iCh]; amp_max[MCPList.at(MCPName.at(iCh))] = ampMax[iCh]; amp_max_corr[MCPList.at(MCPName.at(iCh))] = ampMax[iCh]; charge[MCPList.at(MCPName.at(iCh))] = -intSignal[iCh]; charge_corr[MCPList.at(MCPName.at(iCh))] = -intSignalcorr[iCh]; baseline[MCPList.at(MCPName.at(iCh))] = intBase[iCh]; isPCOn[MCPList.at(MCPName.at(iCh))] = PCOn.at(iCh); HV[MCPList.at(MCPName.at(iCh))] = HVVal.at(iCh); if (strcmp((MCPName.at(iCh)).c_str(),trig1.c_str())==0) isTrigger[MCPList.at(MCPName.at(iCh))] = 1; // else if (strcmp((MCPName.at(iCh)).c_str(),trig2.c_str())==0) isTrigger[MCPList.at(MCPName.at(iCh))] = 2; else isTrigger[MCPList.at(MCPName.at(iCh))] = 0; wfHisto[iCh]->Delete(); } run_id = run; X0 = X0temp; t1->GetEntry(iEntry); tdcX = (*TDCreco)[0]; tdcY = (*TDCreco)[1]; if (spill!=spillNumber || event!=evtNumber) { std::cout<<"PROBLEM: non-coherent read"<<std::endl; continue; } outTree->Fill(); } //---Get ready for next run chain->Delete(); t1->Delete(); }
/* * Realiza la compresión del stream. */ void compress(int argc, char *argv[]) { int i; int c; int look_ahead_bytes; int current_position; int replace_count; int match_length; int match_position; /* Carga el buffer de anticipación. */ current_position = 1; for ( i = 0 ; i < LOOK_AHEAD_SIZE ; i++ ) { if ( ( c = getchar() ) == EOF ) break; window[ current_position + i ] = (unsigned char) c; } look_ahead_bytes = i; /* look_ahead_bytes = 17, excepto al final de la compresión. */ /* Inicializa el árbol de búsqueda binario. */ InitTree( current_position ); /* Longitud de la cadena encontrada. */ match_length = 0; /* Posición de la cadena encontrada. */ match_position = 0; /* Comienza la compresión. */ while ( look_ahead_bytes > 0 ) { if ( match_length > look_ahead_bytes ) match_length = look_ahead_bytes; /* Decidimos si enviar una "k" o un código "ij". */ if ( match_length <= MIN_ENCODED_STRING_SIZE ) { /* "k": Un-encoded output. */ bitio__put_bit(1); bitio__put_bits(window[ current_position ], 8); replace_count = 1; } else { /* "ij": Encoded output. */ bitio__put_bit(0); bitio__put_bits(match_position, INDEX_SIZE); bitio__put_bits((match_length - (MIN_ENCODED_STRING_SIZE + 1)), LENGTH_SIZE ); replace_count = match_length; } /* Insertamos "replace_count" símbolos en el buffer de anticipación y los eleiminados del diccionario.*/ for ( i = 0 ; i < replace_count ; i++ ) { /* Eliminamos del árbol binario de búsqueda los símbolos que salen por la parte izquierda de la ventana deslizante. */ DeleteString( MOD_WINDOW( current_position + LOOK_AHEAD_SIZE ) ); /* Leemos los nuevos símbolos. */ if ( ( c = getchar() ) == EOF ) look_ahead_bytes--; else window[ MOD_WINDOW( current_position + LOOK_AHEAD_SIZE ) ] = (unsigned char) c; /* Actualizamos el "puntero" por el que vamos comprimiendo el stream de datos. No olvidemos que lo procesamos usando una cola circular. */ current_position = MOD_WINDOW( current_position + 1 ); /* Insertamos en el árbol binario de búsqueda los nuevos símbolos. */ if ( look_ahead_bytes ) match_length = AddString( current_position, &match_position ); } }; /* EOF alcanzado. */ bitio__put_bit(0); bitio__put_bits(END_OF_STREAM, INDEX_SIZE); bitio__flush(); }
/* ______________________________________________________________________________________________ Main ______________________________________________________________________________________________ */ int main(int argc, char *argv[]) { // --- Init Cluster variable --------------------------------------------------------- // carmen 0 => local execution i.e. show time on screen // carmen 1 => cluster execution i.e. refresh Performance.dat (default) #if defined PARMPI // --- MPI Runtime system initialization // size - total number of processors // rnak - current CPU MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); #else size=1; rank=0; #endif if (argc == 2) Cluster = atoi(argv[1]); // --- Print messages on screen- ----------------------------------------------------- cout << "carmen: begin execution.\n\n"; printf("Carmen %4.2f \n",CarmenVersion); cout << "Copyright (C) 2000-2005 by Olivier Roussel.\n"; cout << "All rights reserved.\n\n"; #if defined PARMPI //Synchronize all parallel branches MPI_Barrier(MPI_COMM_WORLD); #endif CPUTime.start(); // --- Create first node of the tree structure --------------------------------------- Node *Mesh=0; FineMesh *FMesh=0; // --- Init global values (See Parameters.h and Parameters.cpp) ---------------------------- cout << "carmen: init computation ...\n"; InitParameters(); // --- Debug output information for parallel execution ------------------------------------- #if defined PARMPI if (Multiresolution) { printf("\nParallel Multiresolution solver not implemented yet!\n"); exit(0); } printf("My Rank=%d\n",rank); // --- Each CPU print his coordinates in the virtual processor cart ------------------------ printf("Cart_i = %d; Cart_j = %d; Cart_k = %d;\n",coords[0],coords[1],coords[2]); // --- Each CPU print his computation domain printf("Xmin = %lf; XMax = %lf;\n",XMin[1],XMax[1]); printf("Ymin = %lf; YMax = %lf;\n",XMin[2],XMax[2]); printf("Zmin = %lf; ZMax = %lf;\n",XMin[3],XMax[3]); // --- And the local scale number ---------------------------------------------------------- printf("ScaleNb = %d\n",ScaleNb); #endif // --- Allocate ---------------------------------------------------------------------------- if (Multiresolution) Mesh = new Node; else FMesh = new FineMesh; // --- Init tree structure ----------------------------------------------------------------- if (Multiresolution) { InitTree(Mesh); RefreshTree(Mesh); } // --- Compute initial integral values and init time step ---------------------------------- if (Multiresolution) Mesh->computeIntegral(); else FMesh->computeIntegral(); // -- Write integral values -- // -- Compute initial time step -- InitTimeStep(); if (rank==0) PrintIntegral("Integral.dat"); // --- Save initial values into files ------------------------------------------------------ if (PrintEvery == 0) { if (Multiresolution) View(Mesh, "Tree_0.dat", "Mesh_0.dat", "Average_0.dat"); else View(FMesh,"Average_0.dat"); } // --- When PrintEvery != 0, save initial values into specific name format --- if (PrintEvery != 0) { if (Multiresolution) ViewEvery(Mesh, 0); else ViewEvery(FMesh, 0); } // --- Parallel execution only -------------------------------------------- // --- Save to disk DX header for ouput files ----------------------------- // --- This file is needed for the external postprocessing (merging files from the different processors) #if defined PARMPI real tempXMin[4]; real tempXMax[4]; // --- Save original task parameters for the parallel execution int tempScaleNb=ScaleNb; // --- Simulate sequantial running ScaleNb=AllTaskScaleNb; for (int i=0;i<4;i++) { tempXMin[i]=XMin[i]; tempXMax[i]=XMax[i]; // --- Simulate sequantial running XMin[i]=AllXMin[i]; XMax[i]=AllXMax[i]; } // --- Write header with parameters, as we have run sequantial code if (rank==0) FMesh->writeHeader("header.txt"); // Restore variables for (int i=0;i<4;i++) { XMin[i]=tempXMin[i]; XMax[i]=tempXMax[i]; } ScaleNb=tempScaleNb; #endif // --- Done --- cout << "carmen: done.\n"; // --- Write solver type --- if (Multiresolution) cout << "carmen: multiresolution (MR) solver.\n"; else cout << "carmen: finite volume (FV) solver.\n"; // --- Write number of iterations --- if (IterationNb == 1) cout << "carmen: compute 1 iteration ...\n"; else cout << "carmen: compute " << IterationNb << " iterations ...\n"; printf("\n\n\n"); // --- Begin time iteration ---------------------------------------------------------------- for (IterationNo = 1; IterationNo <= IterationNb; IterationNo++) { // --- Time evolution procedure --- if (Multiresolution) TimeEvolution(Mesh); else TimeEvolution(FMesh); // --- Remesh --- if (Multiresolution) Remesh(Mesh); // --- Check CPU Time --- CPUTime.check(); // --- Write information every (Refresh) iteration --- if ((IterationNo-1)%Refresh == 0) { // - Write integral values - if (rank==0) PrintIntegral("Integral.dat"); if (Cluster == 0) ShowTime(CPUTime); // Show time on screen //else if (rank==0) Performance("carmen.prf"); // Refresh file "carmen.prf" } // --- Backup data every (10*Refresh) iteration --- if ((IterationNo-1)%(10*Refresh) == 0 && UseBackup) { if (Multiresolution) Backup(Mesh); else Backup(FMesh); } // --- Print solution if IterationNo = PrintIt1 to PrintIt6 --- if (Multiresolution) ViewIteration(Mesh); else ViewIteration(FMesh); // --- Print solution if IterationNo is a multiple of PrintEvery --- if (PrintEvery != 0) { if (IterationNo%PrintEvery == 0) { if (Multiresolution) ViewEvery(Mesh, IterationNo); else ViewEvery(FMesh, IterationNo); } } // --- End time iteration ------------------------------------------------------------------ } // --- Backup final data ------------------------------------------------------------------ IterationNo--; if (UseBackup) { if (Multiresolution) Backup(Mesh); else Backup(FMesh); } // --- Write integral values --------------------------------------------------------------- if (rank==0) PrintIntegral("Integral.dat"); IterationNo++; // --- Save values into file --------------------------------------------------------------- if (Multiresolution) View(Mesh, "Tree.dat", "Mesh.dat", "Average.dat"); else View(FMesh, "Average.dat"); cout << "\ncarmen: done.\n"; // --- Analyse performance and save it into file ------------------------------------------- if (rank==0) Performance("carmen.prf"); // --- End --------------------------------------------------------------------------------- if (Multiresolution) delete Mesh; else delete FMesh; #if defined PARMPI //free memory for the MPI runtime variables delete[] disp; delete[] blocklen; int sz; MPI_Buffer_detach(&MPIbuffer,&sz); // for (int i = 0; i < 4*Dimension; i++) MPI_Request_free(&req[i]); MPI_Finalize(); #endif cout <<"carmen: end execution.\n"; return EXIT_SUCCESS; }
HeronLocalFileStateMgr::HeronLocalFileStateMgr(const std::string& _topleveldir, EventLoop* eventLoop) : HeronStateMgr(_topleveldir), eventLoop_(eventLoop) { InitTree(); }
void PageDetail::Init(Scenario *pScenario) { m_pCompManager = pScenario->GetCompManager(); m_pScenario = pScenario; InitTree(); }
//--------------------------------------------------------------------------------------- // hlavni funkce se spoustou testu na overeni funkcnosti //--------------------------------------------------------------------------------------- int main(void) { Node *treeSet = InitTree(); simplePrintAll(treeSet, 0); // test 1 printf("Test 1.:"); Node *r = findNodeByKey(treeSet, "IB002 Algorithms and data structures I"); Node *algoritmy = findNodeByKey(treeSet, "algorithms"); Node *found = findMinimalRootOfNodes(r, algoritmy); if (found == r) { printf("OK \n"); } else { printf("Chyba: nalezeny uzel mel byt (%s), ale vas uzel byl (%s) \n", r->key, found->key); } // test 2 printf("Test 2.:"); found = findMinimalRootOfNodes(algoritmy, algoritmy); if(found == algoritmy) { printf("OK \n"); } else { printf("Chyba: nalezeny uzel mel byt (%s), ale vas uzel byl (%s) \n", algoritmy->key, found->key); } // test 3 printf("Test 3.:"); Node *heapSort = findNodeByKey(r, "heap sort"); Node *selectSort = findNodeByKey(r, "select sort"); found = findMinimalRootOfNodes(heapSort, selectSort); if (found == findNodeByKey(r, "searching algorithms")) { printf("OK \n"); } else { printf("Chyba, nalezeny uzel mel byt (%s), ale vas uzel byl (%s) \n", findNodeByKey(r, "searching algorithms")->key, found->key); } // test 4 printf("Test 4.:"); Node *graphs = findNodeByKey(r, "graphs"); Node *directedGraph = findNodeByKey(r, "directed graph"); found = findMinimalRootOfNodes(graphs, directedGraph); if (found == graphs) { printf("OK \n"); } else { printf("Chyba, nalezeny uzel mel byt (%s), ale vas uzel byl (%s) \n", graphs->key, found->key); } // test 5 printf("Test 5.:"); Node *BPlusTree = findNodeByKey(r, "B+ tree"); Node *power = findNodeByKey(r, "power"); found = findMinimalRootOfNodes(BPlusTree, power); if (found == r) { printf("OK \n"); } else { printf("Chyba, nalezeny uzel mel byt (%s), ale vas uzel byl (%s) \n", r->key, found->key); } // test 6 printf("Test 6.:"); Node *dataStructures = findNodeByKey(r, "data structures"); Node *mergeSort = findNodeByKey(r, "merge sort"); found = findMinimalRootOfNodes(dataStructures, mergeSort); if (found == r) { printf("OK \n"); } else { printf("Chyba, nalezeny uzel mel byt (%s), ale vas uzel byl (%s) \n", r->key, found->key); } DestroyTree(treeSet); return 0; }
int main (int argc, char** argv) { // get run number std::string inputName = std::string(argv[1]); char split_char = '/'; std::vector<std::string> tokens; std::istringstream split(inputName); for(std::string each; getline(split, each, split_char); tokens.push_back(each)); split_char = '_'; std::vector<std::string> tokens_name; std::istringstream split_name(tokens.at(1)); for(std::string each; getline(split_name, each, split_char); tokens_name.push_back(each)); const int Ch_ref1 = atoi((tokens_name.at(1)).c_str()); const int Ch_ref2 = atoi((tokens_name.at(3)).c_str()); const int Ch_1 = atoi((tokens_name.at(5)).c_str()); const int Ch_2 = atoi((tokens_name.at(7)).c_str()); const int Ch_3 = atoi((tokens_name.at(9)).c_str()); std::vector<std::string> nameMCP; nameMCP.push_back("MiB1"); nameMCP.push_back("MiB2"); nameMCP.push_back("ScB"); nameMCP.push_back("Planacon"); nameMCP.push_back("MiB3"); nameMCP.push_back("Roma2"); if(tokens_name.at(0) == "Scan3") nameMCP.at(1) = "Roma1"; std::vector<std::string> pcMCP; for(unsigned int ii=0; ii<nameMCP.size(); ++ii) pcMCP.push_back(""); pcMCP.at(Ch_ref1) = tokens_name.at(2); pcMCP.at(Ch_ref2) = tokens_name.at(4); pcMCP.at(Ch_1) = tokens_name.at(6); pcMCP.at(Ch_2) = tokens_name.at(8); pcMCP.at(Ch_3) = tokens_name.at(10); //---treshold setup Scan-dependent init(); const int iScanTh = atoi(argv[2])-1; float Ch_th[6]={0,0,0,0,0,0}; Ch_th[Ch_ref1] = _th[iScanTh][Ch_ref1]; Ch_th[Ch_ref2] = _th[iScanTh][Ch_ref2]; Ch_th[Ch_1] = _th[iScanTh][Ch_1]; Ch_th[Ch_2] = _th[iScanTh][Ch_2]; Ch_th[Ch_3] = _th[iScanTh][Ch_3]; TFile* out = TFile::Open((tokens_name.at(0)+"_outHistos.root").c_str(),"recreate"); out->cd(); //Output dat std::ofstream data1(("analized_data/"+tokens_name.at(0)+"_"+nameMCP.at(Ch_1)+"_pc_"+pcMCP.at(Ch_1)+".dat").data()); std::ofstream data2(("analized_data/"+tokens_name.at(0)+"_"+nameMCP.at(Ch_2)+"_pc_"+pcMCP.at(Ch_2)+".dat").data()); std::ofstream data3(("analized_data/"+tokens_name.at(0)+"_"+nameMCP.at(Ch_3)+"_pc_"+pcMCP.at(Ch_3)+".dat").data()); int nFiles = 1, iRun = 0, goodEvt = 0; int iScan = 0; //---usefull histos TH1F* chHistoBase_All[9]; TH1F* chHistoSignal_All[9]; TH1F* timeDiffHisto[9]; TH1F* timeDiffHisto_Double = new TH1F("timeDiffHisto_Double", "timeDiffHisto_Double",5000,-10,10); //---histos initialization for(int iCh=0; iCh<6; ++iCh) { char h1[30], h2[30], h3[30]; sprintf(h1, "histoBase_All_Ch%d", iCh); sprintf(h2, "histoSignal_All_Ch%d", iCh); sprintf(h3, "histoTime_Ch%d", iCh); chHistoBase_All[iCh] = new TH1F(h1,h1,30000,-30000,1000); chHistoSignal_All[iCh] = new TH1F(h2, h2,30000,-30000,1000); timeDiffHisto[iCh] = new TH1F(h3, h3,1024,0,1024); } //---do runs loop ifstream log (argv[1], ios::in); while(log >> nFiles) { ++iScan; vector<float> digiCh[9]; float timeCF[9]; float baseline[9]; float intSignal[9], intBase[9]; int count[5]={0,0,0,0,0}, spare[5]={0,0,0,0,0}, spare2[5]={0,0,0,0,0}; int tot_tr1 = 0, tot_tr0 = 0, trig = 0; int HV1=0, HV2=0, HV3=0; TH1F* chHistoWF_Ch[9]; TH1F* chHistoBase_Ch[9]; TH1F* chHistoSignal_Ch[9]; TH1F* timeDiffHisto_Triple_Ch1 = new TH1F(Form("timeDiffHisto_Triple_Ch1_Scan%d",iScan), "", 5000,-100,100); TH1F* timeDiffHisto_Triple_Ch2 = new TH1F(Form("timeDiffHisto_Triple_Ch2_Scan%d",iScan), "", 5000,-100,100); TH1F* timeDiffHisto_Triple_Ch3 = new TH1F(Form("timeDiffHisto_Triple_Ch3_Scan%d",iScan), "", 5000,-100,100); char ha[10]; for (int iiw=0;iiw<9;++iiw){ sprintf (ha,"histoWF_Ch%d_Scan_%d",iiw, iScan); chHistoWF_Ch[iiw] = new TH1F( ha, "", 1024,0.,1024); chHistoWF_Ch[iiw]->SetXTitle("Waveform"); sprintf (ha,"histoBase_Ch%d_Scan_%d",iiw, iScan); chHistoBase_Ch[iiw] = new TH1F( ha, "", 30000,-30000,1000); chHistoBase_Ch[iiw] -> SetXTitle ("Integral BaseLine Ch(ADC)"); sprintf (ha,"histoSignal_Ch%d_Scan_%d",iiw, iScan); chHistoSignal_Ch[iiw] = new TH1F( ha, "", 30000,-30000,1000); chHistoSignal_Ch[iiw] -> SetXTitle ("Integral Signal Ch(ADC)"); } //---data chain TChain* chain = new TChain("eventRawData"); InitTree(chain); for(int iFiles=0; iFiles<nFiles; iFiles++){ log >> iRun; char iRun_str[30]; sprintf(iRun_str, "../Analysis_TB/DATA/run_IMCP_%d_*.root", iRun); chain->Add(iRun_str); cout << "Reading: ../Analysis_TB/DATA/run_IMCP_" << iRun << endl; } log >> HV1 >> HV2 >> HV3; for(int iEntry=0; iEntry<chain->GetEntries(); iEntry++) { //---always clear the std::vector !!! for(int iCh=0; iCh<9; iCh++) digiCh[iCh].clear(); //---Read the entry chain->GetEntry(iEntry); //---DAQ bug workaround if(iRun < 145) goodEvt = 10; else goodEvt = 1; if(evtNumber % goodEvt == 0){ //---Read SciFront ADC value and set the e- multiplicity //---(default = 1) trig = 1; for(int iCh=0; iCh<nAdcChannels; iCh++) { if(adcData[iCh] > 1500 && adcBoard[iCh] == 1 && adcChannel[iCh] == 0) trig=2; if(adcData[iCh] < 500 && adcBoard[iCh] == 1 && adcChannel[iCh] == 0) trig=0; } if(trig > 1) continue; //---Read digitizer samples for(int iSample=0; iSample<nDigiSamples; iSample++){ if(digiChannel[iSample] == 3){ digiCh[digiChannel[iSample]].push_back(-digiSampleValue[iSample]); chHistoWF_Ch[digiChannel[iSample]]->SetBinContent(digiSampleIndex[iSample]+1, -digiSampleValue[iSample]); } else{ digiCh[digiChannel[iSample]].push_back(digiSampleValue[iSample]); chHistoWF_Ch[digiChannel[iSample]]->SetBinContent(digiSampleIndex[iSample]+1, digiSampleValue[iSample]); } } for(int iCh=0; iCh<6; iCh++){ // baseline[iCh] = SubtractBaseline(5, 25, &digiCh[iCh]); baseline[iCh] = SubtractBaseline(26, 46, &digiCh[iCh]); intBase[iCh] = ComputeIntegral(26, 46, &digiCh[iCh]); if(trig == 0) { chHistoBase_All[iCh]->Fill(ComputeIntegral(26, 46, &digiCh[iCh])); chHistoBase_Ch[iCh]->Fill(ComputeIntegral(26, 46, &digiCh[iCh])); // chHistoBase_All[iCh]->Fill(ComputeIntegral(0, 150, &digiCh[iCh])); // chHistoBase_Ch[iCh]->Fill(ComputeIntegral(0, 150, &digiCh[iCh])); } timeCF[iCh]=TimeConstFrac(30, 500, &digiCh[iCh], 0.5); // timeDiffHisto[iCh]->Fill(timeCF[iCh]*0.2-timeCF[0]*0.2); timeDiffHisto[iCh]->Fill(timeCF[iCh]); int t1 = (int)(timeCF[iCh]/0.2) - 3; int t2 = (int)(timeCF[iCh]/0.2) + 17; //---Fill the signal integral histo only if the e- multiplicity is 1 if(t1 > 30 && t1 < 1024 && t2 > 30 && t2 < 1024 && trig == 1) { chHistoSignal_All[iCh]->Fill(ComputeIntegral(t1, t2, &digiCh[iCh])); chHistoSignal_Ch[iCh]->Fill(ComputeIntegral(t1, t2, &digiCh[iCh])); intSignal[iCh] = ComputeIntegral(t1, t2, &digiCh[iCh]); } else intSignal[iCh] = ComputeIntegral(50, 70, &digiCh[iCh]); }// loop over Ch //---Multiplicity == 1 --> compute efficency, fake rate and timing if(intSignal[Ch_ref1] < Ch_th[Ch_ref1] && intSignal[Ch_ref2] < Ch_th[Ch_ref2] && trig == 1){ ++tot_tr1; float tDiff = (timeCF[Ch_ref1] - timeCF[Ch_ref2]); float tMean = (timeCF[Ch_ref1] + timeCF[Ch_ref2])*0.5; timeDiffHisto_Double->Fill(tDiff); timeDiffHisto_Triple_Ch1->Fill(tMean - timeCF[Ch_1]); timeDiffHisto_Triple_Ch2->Fill(tMean - timeCF[Ch_2]); timeDiffHisto_Triple_Ch3->Fill(tMean - timeCF[Ch_3]); if(intSignal[Ch_1] < Ch_th[Ch_1]) ++count[1]; if(intSignal[Ch_2] < Ch_th[Ch_2]) ++count[2]; if(intSignal[Ch_3] < Ch_th[Ch_3]) ++count[3]; if(intBase[Ch_1] < Ch_th[Ch_1]) ++spare[1]; if(intBase[Ch_2] < Ch_th[Ch_2]) ++spare[2]; if(intBase[Ch_3] < Ch_th[Ch_3]) ++spare[3]; } }// good Event }// loop over entries std::cout << "HV1 = " << HV1 << " HV2 = " << HV2 << " HV3 = " << HV3 << std::endl; double eff1 = ((double)count[1]-(double)spare[1])/(double)tot_tr1; double eff2 = ((double)count[2]-(double)spare[2])/(double)tot_tr1; double eff3 = ((double)count[3]-(double)spare[3])/(double)tot_tr1; double eff1Err = TMath::Sqrt((eff1*(1-eff1))/tot_tr1); double eff2Err = TMath::Sqrt((eff2*(1-eff2))/tot_tr1); double eff3Err = TMath::Sqrt((eff3*(1-eff3))/tot_tr1); std::cout << "Ch_1 eff = " << eff1 << " +/- " << eff1Err << std::endl; std::cout << "Ch_2 eff = " << eff2 << " +/- " << eff2Err << std::endl; std::cout << "Ch_3 eff = " << eff3 << " +/- " << eff3Err << std::endl; /* data1 << HV1 << " " << eff1 << " " << 0 << " " << eff1Err << std::endl; data1 << HV2 << " " << eff2 << " " << 0 << " " << eff2Err << std::endl; data1 << HV3 << " " << eff3 << " " << 0 << " " << eff3Err << std::endl; */ for(int iw=0; iw<6; ++iw){ if(iw == 2) continue; chHistoBase_Ch[iw]->Write(); chHistoSignal_Ch[iw]->Write(); chHistoWF_Ch[iw]->Write(); } timeDiffHisto_Triple_Ch1->Write(); timeDiffHisto_Triple_Ch2->Write(); timeDiffHisto_Triple_Ch3->Write(); chain->Delete(); } for(int iw=0; iw<6; ++iw){ if(iw == 2) continue; chHistoBase_All[iw]->Write(); chHistoSignal_All[iw]->Write(); timeDiffHisto[iw]->Write(); } data1.close(); data2.close(); data3.close(); timeDiffHisto_Double->Write(); out->Close(); return 0; }
void main() { CBTType *root=NULL; char menusel; void (*TreeNodeData1)(CBTType *p); TreeNodeData1=TreeNodeData; root = InitTree(); do{ printf("请选择菜单添加二叉树的节点\n"); printf("0.退出\t"); printf("1.添加二叉树的节点\n"); menusel = getch(); switch(menusel) { case '1': AddTreeNode(root); break; case '0': break; default: ; } }while(menusel != '0'); do{ printf("请选择菜单遍历二叉树,输入0表示退出:\n"); printf("1.先序遍历DLR\t"); printf("2.中序遍历LDR\n"); printf("3.后序遍历LRD\t"); printf("4.按层遍历\n"); menusel = getch(); switch(menusel) { case '0': break; case '1': printf("\n 先序遍历DLR的结果:"); DLRTree(root,TreeNodeData1); printf("\n"); break; case '2': printf("\n中序遍历LDR的结果:"); LDRTree(root,TreeNodeData1); printf("\n"); break; case '3': printf("\n 后序遍历LRD的结果:"); LRDTree(root,TreeNodeData1); printf("\n"); break; case '4': printf("\n 按层遍历的结果:"); LevelTree(root,TreeNodeData1); printf("\n"); break; default: ; } }while(menusel != '0'); printf("\n 二叉树深度为:%d \n",TreeDepth(root)); ClearTree(root); root = NULL; }