//--------------------------------------------------------------------------- void __fastcall TLogStrDialog::BtnOkClick(TObject *Sender) { StreamC [0]=Stream1C->Checked; StreamC [1]=Stream2C->Checked; StreamC [2]=Stream3C->Checked; Stream [0]=Stream1 ->ItemIndex; Stream [1]=Stream2 ->ItemIndex; Stream [2]=Stream3 ->ItemIndex; Paths[0][2]=SetFilePath(FilePath1->Text); Paths[1][2]=SetFilePath(FilePath2->Text); Paths[2][2]=SetFilePath(FilePath3->Text); SwapInterval=SwapIntv->Text; LogTimeTag =TimeTagC->Checked; }
bool ClipBitmapStyleDocument::OpenFile(const wxString& strFile) { wxXmlDocument doc; if (!doc.Load(strFile)) return false; Reset(); SetFilePath(strFile); wxXmlNode* pNodeClipBitmapStyleList = doc.GetRoot(); if (!pNodeClipBitmapStyleList || pNodeClipBitmapStyleList->GetName() != wxT("ClipBitmapStyleList")) return false; // parse image list wxXmlNode* pNodeClipBitmapStyle = this->FindXmlChild(pNodeClipBitmapStyleList, wxT("ClipBitmapStyle")); while (pNodeClipBitmapStyle) { ClipBitmapStyle* pClipBitmapStyle = new ClipBitmapStyle(); if (!pClipBitmapStyle->LoadFromXml(pNodeClipBitmapStyle)) { wxMessageDialog msg(&ImagePackerFrame::GetInstance(), wxString::Format(_("load clip bitmap style failed, id=%s"), pClipBitmapStyle->GetId())); msg.ShowModal(); SAFE_DELETE(pClipBitmapStyle); SetModifiedFlag(); } else { m_ClipBitmapStyleMap.insert(std::make_pair(pClipBitmapStyle->GetId(), pClipBitmapStyle)); } pNodeClipBitmapStyle = this->GetNextXml(pNodeClipBitmapStyle, wxT("ClipBitmapStyle")); } return true; }
//--------------------------------------------------- // void TargetNode::ConvertFileName() { char *pszName = GetFileName(), szNewName[2*_MAX_PATH+1]; if ( pszName ) { InternalConvertFileName(pszName, szNewName); DeleteFileName(); SetFileName(szNewName ); } pszName = GetFilePath(); if ( pszName ) { InternalConvertFileName(pszName, szNewName); DeleteFilePath(); SetFilePath(szNewName ); } TargetNode* pTarget = GetFirstChildTarget(); while ( pTarget ) { pTarget->ConvertFileName(); pTarget= pTarget->GetNext(); } }
BOOL AsdkTextFileFieldOptionDialog::SetFieldToEdit(AcDbField* pDbField) { ASSERT(pDbField != NULL); if (pDbField == NULL) return FALSE; //CString sFormat = pDbField->getFormat(); AcFdFieldValue val; Acad::ErrorStatus es = pDbField->getData(TFDATAID,&val); assert( es == Acad::eOk ); if ( es == Acad::eOk ) { const char *sValue; if( val.dataType() != AcFdFieldValue::kString ) return AcDbField::kInvalidCode; else { val.get(sValue); SetFilePath(sValue); } } return TRUE; }
int svlFilterVideoFileWriter::DialogOpenFile(unsigned int videoch) { std::ostringstream out; out << "Save video file [channel #" << videoch << "]"; std::string path, title(out.str()); if (svlVideoIO::DialogFilePath(true, title, path) == SVL_OK) { SetFilePath(path, videoch); // Open codec dialog if (DialogFramerate(videoch) != SVL_OK) { CMN_LOG_CLASS_INIT_WARNING << "DialogOpenFile: failed to set video framerate" << std::endl; } UpdateCodecCount(videoch + 1); if (!CodecParam[videoch]) { // Open codec dialog if (DialogCodec(path, videoch) != SVL_OK || !CodecParam[videoch]) { CMN_LOG_CLASS_INIT_WARNING << "DialogOpenFile: failed to configure video compression" << std::endl; } } return OpenFile(videoch); } return SVL_FAIL; }
int svlFilterVideoFileWriter::Initialize(svlSample* syncInput, svlSample* &syncOutput) { svlSampleImage* img = dynamic_cast<svlSampleImage*>(syncInput); Release(); const unsigned int videochannels = img->GetVideoChannels(); UpdateCodecCount(videochannels); for (unsigned int i = 0; i < videochannels; i ++) { ImageDimensions[i].Assign(img->GetWidth(i), img->GetHeight(i)); // Open file if needed if (!Codec[i] && !FilePath[i].empty()) { SetFilePath(FilePath[i], i); OpenFile(i); } else { CMN_LOG_CLASS_INIT_WARNING << "Initialize: missing file information on channel: " << i << std::endl; } } // Initialize video frame counter VideoFrameCounter = 0; IsRecording = false; syncOutput = syncInput; return SVL_OK; }
CFile::CFile(LPCTSTR pszPath) : m_hLockedFile( INVALID_HANDLE_VALUE ) , m_nFileShareModeOld( SHAREMODE_NOT_EXCLUSIVE ) { if(pszPath){ SetFilePath(pszPath); } }
CImage::CImage(CRenderer *renderer, const std::string& file_path, int x, int y, int rotation, int align, bool bShow) : CRenderBase(renderer), m_pSprite(NULL), m_pTexture(NULL) { SetFilePath(file_path); SetPos(x, y); SetRotation(rotation); SetAlign(align); SetShown(bShow); }
bool CScript::Open( LPCTSTR pszFilename, UINT wFlags ) { ADDTOCALLSTACK("CScript::Open"); // If we are in read mode and we have no script file. // ARGS: wFlags = OF_READ, OF_NONCRIT etc // RETURN: true = success. InitBase(); if ( pszFilename == NULL ) { pszFilename = GetFilePath(); } else { SetFilePath( pszFilename ); } LPCTSTR pszTitle = GetFileTitle(); if ( pszTitle == NULL || pszTitle[0] == '\0' ) return( false ); LPCTSTR pszExt = GetFilesExt( GetFilePath() ); if ( pszExt == NULL ) { TCHAR szTemp[ _MAX_PATH ]; strcpy( szTemp, GetFilePath() ); strcat( szTemp, GRAY_SCRIPT ); SetFilePath( szTemp ); wFlags |= OF_TEXT; } if ( !PhysicalScriptFile::Open( GetFilePath(), wFlags )) { if ( ! ( wFlags & OF_NONCRIT )) { g_Log.Event(LOGL_WARN, "'%s' not found...\n", static_cast<LPCTSTR>(GetFilePath())); } return( false ); } return( true ); }
CMapiFolder::CMapiFolder( const CMapiFolder *pCopyFrom) { m_lpEid = NULL; m_cbEid = 0; SetDoImport( pCopyFrom->GetDoImport()); SetDisplayName(pCopyFrom->m_displayName.get()); SetObjectType( pCopyFrom->GetObjectType()); SetEntryID( pCopyFrom->GetCBEntryID(), pCopyFrom->GetEntryID()); SetDepth( pCopyFrom->GetDepth()); SetFilePath(pCopyFrom->m_mailFilePath.get()); }
void NineGridStyleDocument::Reset() { SetFilePath(wxEmptyString); for (TM_NINE_GRID_STYLE::iterator it = m_NineGridStyleMap.begin(); it != m_NineGridStyleMap.end(); ++it) { NineGridStyle* pNineGridStyle = it->second; SAFE_DELETE(pNineGridStyle); } m_NineGridStyleMap.clear(); ClearModifiedFlag(); }
void ClipBitmapStyleDocument::Reset() { SetFilePath(wxEmptyString); for (TM_CLIP_BITMAP_STYLE::iterator it = m_ClipBitmapStyleMap.begin(); it != m_ClipBitmapStyleMap.end(); ++it) { ClipBitmapStyle* pClipBitmapStyle = it->second; SAFE_DELETE(pClipBitmapStyle); } m_ClipBitmapStyleMap.clear(); ClearModifiedFlag(); }
//--------------------------------------------------------------------------- void __fastcall TInputStrDialog::BtnOkClick(TObject *Sender) { StreamC[0] =StreamC1 ->Checked; StreamC[1] =StreamC2 ->Checked; StreamC[2] =StreamC3 ->Checked; Stream[0] =Stream1 ->ItemIndex; Stream[1] =Stream2 ->ItemIndex; Stream[2] =Stream3 ->ItemIndex; Format[0] =Format1 ->ItemIndex; Format[1] =Format2->ItemIndex<NRcv?Format2->ItemIndex:STRFMT_SP3+Format2->ItemIndex-NRcv; Format[2] =Format3->ItemIndex<NRcv?Format3->ItemIndex:STRFMT_SP3+Format3->ItemIndex-NRcv; Paths[0][2]=SetFilePath(FilePath1->Text); Paths[1][2]=SetFilePath(FilePath2->Text); Paths[2][2]=SetFilePath(FilePath3->Text); NmeaReq =NmeaReqL ->ItemIndex; TimeTag =TimeTagC ->Checked; TimeSpeed =TimeSpeedL->Text; TimeStart =TimeStartE->Text; NmeaPos[0] =str2dbl(NmeaPos1->Text); NmeaPos[1] =str2dbl(NmeaPos2->Text); }
bool CImage::UpdateImage(const std::string& file_path, int x, int y, int rotation, int align, bool bShow) { SetFilePath(file_path); SetPos(x, y); SetRotation(rotation); SetAlign(align); SetShown(bShow); ChangeResource(); return true; }
void AsdkTextFileFieldOptionDialog::OnBnClickedBrowse() { struct resbuf *pResBuf; int ret = acedGetFileNavDialog ("Select text file", "", "txt", "Browse Text File", 0, &pResBuf); if ( ret == 5100 && pResBuf->restype == 5005 ) { SetFilePath(pResBuf->resval.rstring); acutRelRb(pResBuf); } }
//-------------------------------------------------------------- // void TargetNode::PullDownPath() { TargetNode *pTarget; char* pszCommonName = GetMakeFileDir(); int nCommonLen = strlen( pszCommonName ); int nLen; SetFileName( pszCommonName ); SetFilePath( pszCommonName ); pTarget= GetFirstChildC(); while ( pTarget ) { nLen = CommonFilePath( pszCommonName, nCommonLen, pTarget->GetFileName() ); if ( nLen ) pTarget->SetFileName( (pTarget->GetFilePath()) + nLen ); pTarget= pTarget->GetNext(); } pTarget= GetFirstChildH(); while ( pTarget ) { nLen = CommonFilePath( pszCommonName, nCommonLen, pTarget->GetFileName() ); if ( nLen ) pTarget->SetFileName( (pTarget->GetFilePath()) + nLen ); pTarget= pTarget->GetNext(); } pTarget= GetFirstChildPRJ(); while ( pTarget ) { if ( pTarget->GetFileName() == NULL ) pTarget->PullDownPath(); else { nLen = CommonFilePath( pszCommonName, nCommonLen, pTarget->GetFileName() ); if ( nLen ) pTarget->SetFileName( (pTarget->GetFileName()) + nLen ); } pTarget= pTarget->GetNext(); } }
bool PhraseDictionaryALSuffixArray::Load(const std::vector<FactorType> &input , const std::vector<FactorType> &output , const std::string &filePath , const std::vector<float> &weight , size_t tableLimit , const LMList &languageModels , const WordPenaltyProducer* wpProducer) { // file path is the directory of the rules for eacg, NOT the file of all the rules SetFilePath(filePath); m_tableLimit = tableLimit; m_input = &input; m_output = &output; m_languageModels = &languageModels; m_wpProducer = wpProducer; m_weight = &weight; return true; }
BOOL CGenethonDoc::OnOpenDocument(const char *pszPathName) { if (IsModified()) TRACE0("Warning: OnOpenDocument replaces an unsaved document\n"); BeginWaitCursor(); DeleteContents(); if ( pGSFiller != NULL ) { delete pGSFiller; pGSFiller = NULL; } if ( !GetMSFFile( pszPathName ) ) { EndWaitCursor(); return FALSE; } // Save the File Path SetFilePath(pszPathName); // user defaults GetNewUserDefaults( ); // Set printer orientation for this file. ((CGenethonApp *)AfxGetApp())->SetLandscape( m_UserVars.m_Orientation ); SetModifiedFlag(FALSE); // start off with unmodified EndWaitCursor(); return TRUE; }
bool TRenderApplication::applicationDidFinishLaunching(){ Director* director = Director::getInstance(); EGLView* glView = EGLView::getInstance(); director->setOpenGLView(glView); Size FrameSize = glView->getFrameSize(); glView->setDesignResolutionSize(900,600,ResolutionPolicy::NO_BORDER); director->setDisplayStats(false); director->setAnimationInterval(1.0/60); SetFilePath(std::string("..\\resource\\")); Scene* scene = Scene::create(); TBaseObject * worklayer = new TBaseObject; if(worklayer && worklayer->initWithColor(Color4B(0,100,100,255))){ SetWorkScene((int)worklayer); worklayer->setScale(0.35f); worklayer->autorelease(); scene->addChild(worklayer); } scene->setPositionX(-200); scene->setPositionY(100); director->runWithScene(scene); return true; }
Pywrap::Pywrap(const char* file, unsigned int arg_size) { if(file != "") { if(findString(".py",file)>= 0) { file = sliceStr(file,0,std::string(file).size() - 3).c_str(); } SetFilePath(file); name_space = PyString_FromString(file); module = PyImport_Import(name_space); PyErr_Print();//get error output if import fails :). Py_DECREF(name_space); fileLoaded = true; } else { fileLoaded = false; } args = PyTuple_New(arg_size); sizeT = arg_size; index = 0; }
PerformanceEvaluator::PerformanceEvaluator(string filepath):PerformanceEvaluator(){ SetFilePath(filepath); }
FilePath& FilePath::operator=(std::string file) { SetFilePath(file); return *this; }
int svlFilterVideoFileWriter::OpenFile(const std::string &filepath, unsigned int videoch) { if (SetFilePath(filepath, videoch) != SVL_OK || OpenFile(videoch) != SVL_OK) return SVL_FAIL; return SVL_OK; }
bool JNet<Dtype>::Init(const string filename){ SetFilePath(filename); // 遍历所有 layer 的 type 参数,统计不同种类 layer 个数 for (int i = 0; i < m_param->GetLayerNum(); i++){ JLayer<Dtype> layer_param_temp; layer_param_temp.SetSharedParam( m_param->GetLayerParam(i)); if (layer_param_temp.GetType() == "Data") m_data_layer_num++; if (layer_param_temp.GetType() == "Convolution") m_convolution_layer_num++; } // 为所有不同类型 layer 开辟内存空间 m_convolution_layers = new JConvolutionLayer<Dtype>[m_convolution_layer_num]; m_data_layers = new JDataLayer<Dtype>[m_data_layer_num]; m_pooling_layers = new JPoolingLayer<Dtype>[m_pooling_layer_num]; // 分别设置所有 layer 的参数 int i_convolution_layer_idex = 0; int i_data_layer_idex = 0; int i_pooling_layer_idex = 0; for (int i = 0; i < m_param->GetLayerNum(); i++){ JLayer layer_param_temp; layer_param_temp.SetSharedParam( m_param->GetLayerParam(i)); if (layer_param_temp.GetType() == "Data"){ m_data_layers[i_data_layer_idex].Init( m_param->GetLayerParam(i)); m_layers.push_back( &m_data_layers[i_data_layer_idex]); i_data_layer_idex++; } if (layer_param_temp.GetType() == "Convolution"){ m_convolution_layers[i_convolution_layer_idex].Init( m_param->GetLayerParam(i)); m_layers.push_back( &m_convolution_layers[i_convolution_layer_idex]); i_convolution_layer_idex++; } if (layer_param_temp.GetType() == "Pooling"){ m_pooling_layers[i_pooling_layer_idex].Init( m_param->GetLayerParam(i)); m_layers.push_back( &m_pooling_layers[i_pooling_layer_idex]); i_pooling_layer_idex++; } //if (layer_param_temp.GetType() == "ReLU"){ // m_conv_layers[i_relu_layer_idex].Init( // m_param->GetLayerParam(i)); // m_layers.push_back( // &m_conv_layers[i_relu_layer_idex]); // i_relu_layer_idex++; //} //if (layer_param_temp.GetType() == "LRN"){ // m_conv_layers[conv_layer_idex].Init( // m_param->GetLayerParam(i)); // m_layers.push_back( // &m_conv_layers[conv_layer_idex]); // conv_layer_idex++; //} //if (layer_param_temp.GetType() == "InnerProduct"){ // m_conv_layers[conv_layer_idex].Init( // m_param->GetLayerParam(i)); // m_layers.push_back( // &m_conv_layers[conv_layer_idex]); // conv_layer_idex++; //} //if (layer_param_temp.GetType() == "Dropout"){ // m_conv_layers[conv_layer_idex].Init( // m_param->GetLayerParam(i)); // m_layers.push_back( // &m_conv_layers[conv_layer_idex]); // conv_layer_idex++; //} //if (layer_param_temp.GetType() == "Softmax"){ // m_conv_layers[conv_layer_idex].Init( // m_param->GetLayerParam(i)); // m_layers.push_back( // &m_conv_layers[conv_layer_idex]); // conv_layer_idex++; //} } for (int i = 0; i < m_layers.size(); i++){ m_layers.at(i)->Show(); } return true; }
void RunTests() { #pragma mark Vacuum Mass Zeroed Equation if (true) { printf("\tVacuum Mass Zeroed Equation\n"); SetFilePath("tests/vacuum-mass-equation/data/"); SetParametersSet(options.parameterization); double min_mass = 0.0; double max_mass = 1000.0; int points_number = 1000; double step = Step(min_mass, max_mass, points_number); FILE * f = OpenFile("vacuum_mass_equation.dat"); double m = 0; while (m < points_number) { fprintf(f, "%20.15E\t%20.15E\n", m, VacuumMassEquation(m, NULL)); m += step; } fclose(f); SetFilePath("tests/vacuum-mass-equation/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "The following tests were executed for %s parameterization:\n", parameters.parameters_set_identifier); fprintf(log_file, "\tVacuum mass equation calculation.\n\n"); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark ZeroedGapEquation if (true) { printf("\tVacuum Mass Zeroed Equation\n"); SetFilePath("tests/vacuum-mass-equation/data/"); SetParametersSet(options.parameterization); double min_mass = 0.0; double max_mass = 1000.0; int points_number = 1000; double step = Step(min_mass, max_mass, points_number); double barionic_density[4] = {parameters.loop_variable.min_value, parameters.loop_variable.max_value * 1.0 / 3.0, parameters.loop_variable.max_value * 2.0 / 3.0, parameters.loop_variable.max_value}; for (int i = 0; i < 4; i++){ double fermi_momentum = CONST_HBAR_C * pow(3.0 * pow(M_PI, 2.0) * barionic_density[i] / NUM_FLAVORS, 1.0 / 3.0); char filename[256]; sprintf(filename, "zeroed_gap_equation_%d.dat", i); FILE * f = OpenFile(filename); gap_equation_input input; input.fermi_momentum = fermi_momentum; double m = 0; while (m < max_mass) { fprintf(f, "%20.15E\t%20.15E\n", m, ZeroedGapEquation(m, &input)); m += step; } } SetFilePath("tests/vacuum-mass-equation/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "The following tests were executed for %s parameterization:\n", parameters.parameters_set_identifier); fprintf(log_file, "\tZeroed gap equation calculation\n\n"); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark Zeroed Renormalized Chemical Potential if (true) { printf("\tVacuum Mass Zeroed Equation\n"); SetFilePath("tests/vacuum-mass-equation/data/"); SetParametersSet(options.parameterization); double mass = 0; double chemical_potential = 0; double min_renormalized_chemical_potential = 0.0; double max_renormalized_chemical_potential = 1000.0; int points_number = 1000; double step = Step(min_renormalized_chemical_potential, max_renormalized_chemical_potential, points_number); FILE * f = OpenFile("zeroed_renorm_chemical_pot_equation.dat"); renorm_chem_pot_equation_input input; input.chemical_potential = chemical_potential; input.mass = mass; double mu = 0; while (mu < points_number) { fprintf(f, "%20.15E\t%20.15E\n", mu, ZeroedRenormalizedChemicalPotentialEquation(mu, &input)); mu += step; } fclose(f); SetFilePath("tests/vacuum-mass-equation/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "The following tests were executed for %s parameterization:\n", parameters.parameters_set_identifier); fprintf(log_file, "\tZeroed renormalized chemical potential equation calculation\n\n"); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark Reproduce Fig. 1 (right) from M. Buballa, Nuclear Physics A 611 // Reproduce Fig. 1 (right) from M. Buballa, Nuclear Physics A 611 (1996) 393-408 // (the figure uses parameters of Set II from the article) if (true) { printf("\tReproduce Fig. 1 (right) from M. Buballa, Nuclear Physics A 611\n"); SetFilePath("tests/Buballa-Fig1-R/data/"); SetParametersSet("Buballa_2"); double chemical_potential[4] = {0.0, 350.0, 378.5, 410.0}; double vacuum_mass = VacuumMassDetermination(); double vacuum_thermodynamic_potential = ThermodynamicPotential(vacuum_mass, 0.0, 0.0, 0.0); for (int i = 0; i < 4; i++){ double minimum_mass = 0.0; double maximum_mass = 1000.0; int points_number = 1000; double step = (maximum_mass - minimum_mass) / (points_number - 1); gsl_vector * mass_vector = gsl_vector_alloc(points_number); gsl_vector * output = gsl_vector_alloc(points_number); double m = 0; for (int j = 0; j < points_number; j++) { double renormalized_chemical_potential = chemical_potential[i]; double fermi_momentum = 0; if (pow(renormalized_chemical_potential, 2.0) > pow(m, 2.0)){ fermi_momentum = sqrt(pow(renormalized_chemical_potential, 2.0) - pow(m, 2.0)); } double thermodynamic_potential = ThermodynamicPotential(m, fermi_momentum, chemical_potential[i], renormalized_chemical_potential); gsl_vector_set(mass_vector, j, m); gsl_vector_set(output, j, thermodynamic_potential - vacuum_thermodynamic_potential); m += step; } char filename[256]; sprintf(filename, "Fig1_Buballa_%d.dat", i); WriteVectorsToFile(filename, "# mass, thermodynamic potential\n", 2, mass_vector, output); } SetFilePath("tests/Buballa-Fig1-R/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "The following tests were executed for %s parameterization:\n", parameters.parameters_set_identifier); fprintf(log_file, "\tCalculation of vacuum mass, resultin in %f MeV.\n", vacuum_mass); fprintf(log_file, "\tCalculation of the thermodynamic potential as function of mass " "(Reproduce Fig. 1 (right) from M. Buballa, Nuclear Physics A 611 (1996) 393-408).\n" "\tfiles: tests/data/Fig1_Buballa_*.dat\n"); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark Reproduce Fig. 2.8 (left) from M. Buballa, Physics Reports // Reproduce Fig. 2.8 (left) from M. Buballa, Physics Reports 407 (2005) 205-376 // (the figure uses parameters of Set II from the article, with G_V = 0) if (true) { printf("\tReproduce Fig. 2.8 (left) from M. Buballa, Physics Reports\n"); SetFilePath("tests/Buballa-Fig2.8-L/data/"); SetParametersSet("BuballaR_2"); int points_number = 1000; parameters.model.bare_mass = 0; // In the reference, the bare mass was // zero for this test double mass = 0; double chemical_potential[4] = {0.0, 300.0, 368.6, 400.0}; double min_renormalized_chemical_potential = 0.0; double max_renormalized_chemical_potential = 1000; double min_mass = 0.0; double max_mass = 1000.0; double renorm_chem_pot_step = Step(min_renormalized_chemical_potential, max_renormalized_chemical_potential, points_number); double mass_step = Step(min_mass, max_mass, points_number); double vacuum_mass = VacuumMassDetermination(); double vacuum_thermodynamic_potential = ThermodynamicPotential(vacuum_mass, 0.0, 0.0, 0.0); for (int i = 0; i < 4; i++){ char filename_1[256]; sprintf(filename_1, "ZeroedRenormalizedChemPotEquation_BR2L_%d.dat", i); FILE * f = OpenFile(filename_1); renorm_chem_pot_equation_input input; input.chemical_potential = chemical_potential[i]; input.mass = mass; double mu = 0; while (mu < points_number) { fprintf(f, "%20.15E\t%20.15E\n", mu, ZeroedRenormalizedChemicalPotentialEquation(mu, &input)); mu += renorm_chem_pot_step; } fclose(f); gsl_vector * mass_vector = gsl_vector_alloc(points_number); gsl_vector * output = gsl_vector_alloc(points_number); double m = 0; for (int j = 0; j < points_number; j++) { double renormalized_chemical_potential = chemical_potential[i]; double fermi_momentum = 0; if (pow(renormalized_chemical_potential, 2.0) > pow(m, 2.0)){ fermi_momentum = sqrt(pow(renormalized_chemical_potential, 2.0) - pow(m, 2.0)); } double thermodynamic_potential = ThermodynamicPotential(m, fermi_momentum, chemical_potential[i], renormalized_chemical_potential); gsl_vector_set(mass_vector, j, m); gsl_vector_set(output, j, thermodynamic_potential - vacuum_thermodynamic_potential); m += mass_step; } char filename[256]; sprintf(filename, "Fig2.8L_BuballaR_%d.dat", i); WriteVectorsToFile(filename, "# mass, thermodynamic potential\n", 2, mass_vector, output); } SetFilePath("tests/Buballa-Fig2.8-L/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "The following tests were executed for %s parameterization:\n", parameters.parameters_set_identifier); fprintf(log_file, "\tCalculation of the hermodynamic potential as function of mass " "(Reproduce Fig. 2.8 (left) from M. Buballa, Physics Reports 407 (2005) 205-376.\n" "\tFiles:tests/data/Fig2.8L_BuballaR_*.dat\n"); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark Reproduce Fig. 2.8 (right) from M. Buballa, Physics Reports // Reproduce Fig. 2.8 (right) from M. Buballa, Physics Reports 407 (2005) 205-376 // (the figure uses parameters of Set II from the article, with G_V = G_S) if (true) { printf("\tReproduce Fig. 2.8 (right) from M. Buballa, Physics Reports\n"); SetFilePath("tests/Buballa-Fig2.8-R/data/"); SetParametersSet("BuballaR_2_GV"); int points_number = 1000; parameters.model.bare_mass = 0; // In the reference, the bare mass was // zero for this test double chemical_potential[4] = {0.0, 430.0, 440.0, 444.3}; double mass[4] = {1.0, 100, 300, 700}; double min_renorm_chemical_potential = 0.0; double max_renorm_chemical_potential = 1000.0; double step = Step(min_renorm_chemical_potential, max_renorm_chemical_potential, points_number); for (int i = 0; i < 4; i++){ for (int j = 0; j < 4; j++){ char filename_1[256]; sprintf(filename_1, "ZeroedRenormalizedChemPotEquation_BR2R_%d_%d.dat", i, j); FILE * f = OpenFile(filename_1); renorm_chem_pot_equation_input input; input.chemical_potential = chemical_potential[i]; input.mass = mass[j]; double mu = 0; while (mu < points_number) { fprintf(f, "%20.15E\t%20.15E\n", mu, ZeroedRenormalizedChemicalPotentialEquation(mu, &input)); mu += step; } fclose(f); } } double vacuum_mass = VacuumMassDetermination(); double vacuum_thermodynamic_potential = ThermodynamicPotential(vacuum_mass, 0.0, 0.0, 0.0); for (int i = 0; i < 4; i++){ double minimum_mass = 0.0; double maximum_mass = 1000.0; int points_number = 1000; double step = (maximum_mass - minimum_mass) / (points_number - 1); gsl_vector * mass_vector = gsl_vector_alloc(points_number); gsl_vector * output = gsl_vector_alloc(points_number); gsl_vector * renormalized_chemical_potential_vector = gsl_vector_alloc(points_number); // Prepare function to be passed to the root finding algorithm gsl_function F; renorm_chem_pot_equation_input input; F.function = &ZeroedRenormalizedChemicalPotentialEquation; F.params = &input; /* * Determine the renormalized chemical potential by root-finding * for each value of mass */ RenormalizedChemicalPotentialIntegrationParameters params = parameters.renormalized_chemical_potential_integration; double m = 0; for (int j = 0; j < points_number; j++) { double renormalized_chemical_potential; // Prepare input for ZeroedRenormalizedChemicalPotentialEquation input.chemical_potential = chemical_potential[i]; input.mass = m; // If the chemical potential is zero, the solution is zero. // Otherwise it needs to be calculated if (chemical_potential[i] == 0){ renormalized_chemical_potential = 0; } else{ int status = UnidimensionalRootFinder(&F, params.lower_bound, params.upper_bound, params.abs_error, params.rel_error, params.max_iter, &renormalized_chemical_potential); if (status == -1) renormalized_chemical_potential = 0; } gsl_vector_set(renormalized_chemical_potential_vector, j, renormalized_chemical_potential); double fermi_momentum = 0; if (pow(renormalized_chemical_potential, 2.0) > pow(m, 2.0)){ fermi_momentum = sqrt(pow(renormalized_chemical_potential, 2.0) - pow(m, 2.0)); } double thermodynamic_potential = ThermodynamicPotential(m, fermi_momentum, chemical_potential[i], renormalized_chemical_potential); gsl_vector_set(mass_vector, j, m); gsl_vector_set(output, j, thermodynamic_potential - vacuum_thermodynamic_potential); m += step; } char filename[256]; sprintf(filename, "Fig2.8R_BuballaR_%d.dat", i); WriteVectorsToFile(filename, "# mass, thermodynamic potential\n", 2, mass_vector, output); sprintf(filename, "renormalized_chemical_potential_%d.dat", i); WriteVectorsToFile(filename, "#mass, renormalized_chemical_potential\n", 2, mass_vector, renormalized_chemical_potential_vector); gsl_vector_free(output); gsl_vector_free(mass_vector); gsl_vector_free(renormalized_chemical_potential_vector); } SetFilePath("tests/Buballa-Fig2.8-R/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "The following tests were executed for %s parameterization:\n", parameters.parameters_set_identifier); fprintf(log_file, "\tCalculation of the thermodynamic potential as function of mass " "(Reproduce Fig. 2.8 (right) from M. Buballa, Physics Reports 407 (2005) 205-376.\n" "\tFiles:tests/data/Fig2.8R_BuballaR_*.dat\n"); fprintf(log_file, "\tZeroed renormalized chemical potential equation for selected parameters" " (as function of renormalized chemical potential)\n"); fprintf(log_file, "\tRenormalized chemical potential (as function of mass)\n"); fprintf(log_file, "\tVacuum mass: %f\n", vacuum_mass); fprintf(log_file, "\tVacuum thermodynamic potential: %f\n", vacuum_thermodynamic_potential); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark Fermi-Dirac Distributions // Prints Fermi-Dirac distributions for selected values of temperature // and chemical potential as function of momentum if (true) { printf("\tFermi-Dirac Distributions\n"); SetFilePath("tests/Fermi-Dirac-distributions/data/"); int n_pts = 1000; double min_momentum = 0.0; double max_momentum = 400.0; double step = (max_momentum - min_momentum) / (n_pts - 1); double temperature[4] = {5, 10.0, 20.0, 30.0}; double chemical_potential[4] = {50.0, 100.0, 200.0, 300.0}; double mass[4] = {50.0, 100.0, 150.0, 200.0}; gsl_vector * momentum_vector = gsl_vector_alloc(n_pts); gsl_vector * fp_vector = gsl_vector_alloc(n_pts); gsl_vector * fa_vector = gsl_vector_alloc(n_pts); for (int i = 0; i < 4; i++){ // temperature for (int j = 0; j < 4; j++){ // chemical potential for (int k = 0; k < 4; k++){ // mass double momentum = min_momentum; for (int l = 0; l < n_pts; l++){ double energy = sqrt(pow(momentum, 2.0) + pow(mass[k], 2.0)); double fp = FermiDiracDistributionForParticles(energy, chemical_potential[j], temperature[i]); double fa = FermiDiracDistributionForAntiparticles(energy, chemical_potential[j], temperature[i]); gsl_vector_set(momentum_vector, l, momentum); gsl_vector_set(fp_vector, l, fp); gsl_vector_set(fa_vector, l, fa); momentum += step; } char filename[256]; sprintf(filename, "FD_%d_%d_%d.dat", i, j, k); WriteVectorsToFile(filename, "# momentum, Fermi-Dirac distribution for particles, = for antiparticles\n", 3, momentum_vector, fp_vector, fa_vector); } } } gsl_vector_free(momentum_vector); gsl_vector_free(fp_vector); gsl_vector_free(fa_vector); SetFilePath("tests/Fermi-Dirac-distributions/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "Prints Fermi-Dirac distributions for selected values of temperature\n" "and chemical potential as function of momentum\n"); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark Fermi-Dirac Distribution Integrals // Tests integration of Fermi-Dirac distributions if (true) { printf("\tFermi-Dirac Distribution Integrals\n"); SetFilePath("tests/Fermi-Dirac-distrib-integrals/data/"); SetParametersSet("BuballaR_2"); int num_points = 1000; double min_mass = 0.01; double max_mass = 1000; double step = (max_mass - min_mass) / ((double)(num_points - 1)); double renormalized_chemical_potential[4] = {100.0, 200.0, 400.0, 600.0}; double temperature[4] = {5.0, 10.0, 15.0, 20.0}; gsl_vector * mass_vector = gsl_vector_alloc(num_points); gsl_vector * fermi_dirac_int_1 = gsl_vector_alloc(num_points); gsl_vector * fermi_dirac_int_2 = gsl_vector_alloc(num_points); for (int i = 0; i < 4; i++){ parameters.finite_temperature.temperature = temperature[i]; for (int j = 0; j < 4; j++){ double m = min_mass; for (int k = 0; k < num_points; k++){ double int_1 = FermiDiracDistributionFromDensityIntegral(m, renormalized_chemical_potential[j]); double int_2 = FermiDiracDistributionIntegralFromGapEquation(m, renormalized_chemical_potential[j]); gsl_vector_set(mass_vector, k, m); gsl_vector_set(fermi_dirac_int_1, k, int_1); gsl_vector_set(fermi_dirac_int_2, k, int_2); m += step; } char filename[256]; sprintf(filename, "fermi_dirac_distribution_from_density_integral_%d_%d.dat", i, j); WriteVectorsToFile(filename, "# mass, integral of fermi dirac dist from density\n", 2, mass_vector, fermi_dirac_int_1); sprintf(filename, "fermi_dirac_distribution_from_gap_eq_integral_%d_%d.dat", i, j); WriteVectorsToFile(filename, "# mass, integral of fermi dirac dist from gap eq\n", 2, mass_vector, fermi_dirac_int_2); } } gsl_vector_free(mass_vector); gsl_vector_free(fermi_dirac_int_1); gsl_vector_free(fermi_dirac_int_2); SetFilePath("tests/Fermi-Dirac-distrib-integrals/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "The following tests were executed for %s parameterization:\n", parameters.parameters_set_identifier); fprintf(log_file, "\tCalculation of integrals of fermi distributions as function of mass.\n"); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark Mass Gap Zeroed Equation for Selected Temperatures // writes gap equation as function of mass for selected temperatures // What exactly is that? I don't remember ... // if (true) { printf("\tMass Gap Zeroed Equation for Selected Temperatures\n"); SetFilePath("tests/zeroed-gap-equation/data/"); SetParametersSet("BuballaR_2"); int n_pts = 1000; double min_mass = 0.0; double max_mass = 1000.0; double step = (max_mass - min_mass) / (n_pts - 1); double temperature[4] = {5.0, 10.0, 15.0, 20.0}; double renormalized_chemical_potential[4] = {100.0, 200.0, 400.0, 600.0}; gsl_vector * m_vector = gsl_vector_alloc(n_pts); gsl_vector * zeroed_gap_vector = gsl_vector_alloc(n_pts); for (int i = 0; i < 4; i++){ parameters.finite_temperature.temperature = temperature[i]; for (int j = 0; j < 4; j++){ double m = min_mass; for (int k = 0; k < n_pts; k++){ double integ = FermiDiracDistributionIntegralFromGapEquation(m, renormalized_chemical_potential[j]); gsl_vector_set(zeroed_gap_vector, k, m - parameters.model.bare_mass - integ); gsl_vector_set(m_vector, k, m); m += step; } char filename[256]; sprintf(filename, "zeroed_gap_eq_%d_%d.dat", i, j); WriteVectorsToFile(filename, "# mass, zeroed gap equation\n", 2, m_vector, zeroed_gap_vector); } } gsl_vector_free(m_vector); gsl_vector_free(zeroed_gap_vector); SetFilePath("tests/zeroed-gap-equation/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "The following tests were executed for %s parameterization:\n", parameters.parameters_set_identifier); fprintf(log_file, "\tCalculation of zeroed gap eq for T != 0 as function of mass.\n"); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark Maps of Mass and Renormalized Chemical Potential Zeroed Equations // Calculates zeroed gap and barionic densities equations so we can see both // and have an insight of what's going on if (true) { printf("\tMaps of Mass and Renormalized Chemical Potential Zeroed Equations\n"); SetFilePath("tests/maps/data/"); SetParametersSet("BuballaR_2"); const int num_densities = 10; const int num_temperatures = 10; const double barionic_density[10] = {0.04, 0.08, 0.12, 0.16, 0.2, 0.24, 0.28, 0.32, 0.4, 0.44}; const double temperature[10] = {1.0, 3.0, 7.0, 10.0, 15.0, 20.0, 25.0, 30.0, 40.0, 50.0}; int mass_n_pts = 150; int renorm_chem_pot_n_pts = 150; double min_mass = 0.0; double max_mass = 600.0; double min_renormalized_chemical_potential = 0.0; double max_renormalized_chemical_potential = 600.0; double tolerance_dens = 0.05; double tolerance_gap = 0.5; gsl_vector * map_gap_x = gsl_vector_alloc(mass_n_pts * renorm_chem_pot_n_pts); gsl_vector * map_gap_y = gsl_vector_alloc(mass_n_pts * renorm_chem_pot_n_pts); int map_gap_num_points; gsl_vector * map_dens_x = gsl_vector_alloc(mass_n_pts * renorm_chem_pot_n_pts); gsl_vector * map_dens_y = gsl_vector_alloc(mass_n_pts * renorm_chem_pot_n_pts); int map_dens_num_points; for (int i = 0; i < num_temperatures; i++){ // Temperature parameters.finite_temperature.temperature = temperature[i]; for (int j = 0; j < num_densities; j++){ MapFunction(&ZeroedGapEquationForFiniteTemperature, min_mass, max_mass, mass_n_pts, min_renormalized_chemical_potential, max_renormalized_chemical_potential, renorm_chem_pot_n_pts, tolerance_gap, NULL, false, map_gap_x, map_gap_y, &map_gap_num_points); MapFunction(&ZeroedBarionicDensityEquationForFiniteTemperature, min_mass, max_mass, mass_n_pts, min_renormalized_chemical_potential, max_renormalized_chemical_potential, renorm_chem_pot_n_pts, tolerance_dens, (void *)&(barionic_density[j]), false, map_dens_x, map_dens_y, &map_dens_num_points); double x_intersection; double y_intersection; IntersectionPointOfTwoMaps(map_gap_x, map_gap_y, map_gap_num_points, map_dens_x, map_dens_y, map_dens_num_points, &x_intersection, &y_intersection); char filename[256]; sprintf(filename, "map_gap_%d_%d.dat", i, j); WriteVectorsToFileUpToIndex(filename, "# Map of the region of zeroed gap equation that is near zero\n" "# mass, renormalized chemical potential\n", map_gap_num_points, 2, map_gap_x, map_gap_y); sprintf(filename, "map_dens_%d_%d.dat", i, j); WriteVectorsToFileUpToIndex(filename, "# Map of the region of zeroed density gap equation that is near zero\n" "# mass, renormalized chemical potential\n", map_dens_num_points, 2, map_dens_x, map_dens_y); sprintf(filename, "intersection_%d_%d.dat", i, j); FILE * file = OpenFile(filename); fprintf(file, "%20.15E\t%20.15E\n", x_intersection, y_intersection); fclose(file); } } gsl_vector_free(map_gap_x); gsl_vector_free(map_gap_y); gsl_vector_free(map_dens_x); gsl_vector_free(map_dens_y); SetFilePath("tests/maps/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "Calculates zeroed gap and barionic densities equations so we can see both\n" "and have an insight of what's going on.\n"); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark Mass and Renormalized Chemical Potential for Finite Temperature // Prints mass and renormalized chemical potential calculation as function // of barionic density if (true) { printf("\tMass and Renormalized Chemical Potential for Finite Temperature\n"); SetFilePath("tests/mass-renorm-chem-pot/data/"); SetParametersSet("BuballaR_2"); int n_pts = 100; double min_barionic_density = 0.1; double max_barionic_denstiy = 0.3; double step = (max_barionic_denstiy - min_barionic_density) / ((double)(n_pts - 1)); double temperature[4] = {10.0, 15.0, 20.0, 25.0}; gsl_vector * dens_vector = gsl_vector_alloc(n_pts); gsl_vector * mass_vector = gsl_vector_alloc(n_pts); gsl_vector * renormalized_chemical_potential_vector = gsl_vector_alloc(n_pts); for (int i = 0; i < 4; i++){ double dens = min_barionic_density; parameters.finite_temperature.temperature = temperature[i]; double mass; double renormalized_chemical_potential; for (int j = 0; j < n_pts; j++){ SolveMultiRoots(dens, &mass, &renormalized_chemical_potential); gsl_vector_set(dens_vector, j, dens); gsl_vector_set(mass_vector, j, mass); gsl_vector_set(renormalized_chemical_potential_vector, j, renormalized_chemical_potential); dens += step; } char filename[256]; sprintf(filename, "mass_and_renorm_chem_pot_%d.dat", i); WriteVectorsToFile(filename, "# barionic density, mass, renormalized chemical potential\n", 3, dens_vector, mass_vector, renormalized_chemical_potential_vector); } gsl_vector_free(dens_vector); gsl_vector_free(mass_vector); gsl_vector_free(renormalized_chemical_potential_vector); SetFilePath("tests/mass-renorm-chem-pot/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "The following tests were executed for %s parameterization:\n", parameters.parameters_set_identifier); fprintf(log_file, "\tCalculation of mass and renormalized chemical potential as function of barionic density.\n"); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark Entropy calculation methods (transient) if (true) { printf("\tEntropy calculation methods\n"); SetFilePath("tests/transient/data/"); SetParametersSet("BuballaR_2"); double mass[6] = {50.0, 100.0, 200.0, 300.0, 400.0, 500.0}; double renormalized_chemical_potential[6] = {50.0, 100.0, 200.0, 300.0, 400.0, 500.0}; double temperature[6] = {1.0, 5.0, 7.0, 10.0, 20.0, 35.0}; int n_pts = 1000; double min_momentum = 0.0; double max_momentum = parameters.model.cutoff; double mom_step = (max_momentum - min_momentum) / (double)(n_pts - 1); // FIXME: Remove other methods of calculation once I'm sure the one adopted works fine gsl_vector * momentum_vector = gsl_vector_alloc(n_pts); gsl_vector * entropy_integrand_vector = gsl_vector_alloc(n_pts); gsl_vector * entropy_integrand_vector_deriv = gsl_vector_alloc(n_pts); gsl_vector * entropy_integrand_vector_art = gsl_vector_alloc(n_pts); for (int i = 0; i < 6; i++){ for (int j = 0; j < 6; j++){ for (int k = 0; k < 6; k++){ entropy_integrand_parameters par; par.mass = mass[i]; par.renormalized_chemical_potential = renormalized_chemical_potential[j]; par.temperature = temperature[k]; double p = 0; for (int l = 0; l < n_pts; l++){ double entropy_integrand = EntropyIntegrand(p, &par); double entropy_integrand_deriv = EntropyIntegrandFromDerivative(p, &par); double entropy_integrand_art = EntropyIntegrandArt(p, &par); gsl_vector_set(momentum_vector, l, p); gsl_vector_set(entropy_integrand_vector, l, entropy_integrand); gsl_vector_set(entropy_integrand_vector_deriv, l, entropy_integrand_deriv); gsl_vector_set(entropy_integrand_vector_art, l, entropy_integrand_art); p += mom_step; } char filename[256]; sprintf(filename, "entropy_integrand_%d_%d_%d.dat", i, j, k); WriteVectorsToFile(filename, "# momentum, entropy integrand\n", 2, momentum_vector, entropy_integrand_vector); sprintf(filename, "entropy_integrand_deriv_%d_%d_%d.dat", i, j, k); WriteVectorsToFile(filename, "# momentum, entropy integrand\n", 2, momentum_vector, entropy_integrand_vector_deriv); sprintf(filename, "entropy_integrand_art_%d_%d_%d.dat", i, j, k); WriteVectorsToFile(filename, "# momentum, entropy integrand\n", 2, momentum_vector, entropy_integrand_vector_art); } } } gsl_vector_free(momentum_vector); gsl_vector_free(entropy_integrand_vector); gsl_vector_free(entropy_integrand_vector_deriv); gsl_vector_free(entropy_integrand_vector_art); SetFilePath("tests/transient/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "Verifies the best routine to calculate entropy.\n"); fprintf(log_file, "mass = {50.0, 100.0, 200.0, 300.0, 400.0, 500.0};\n" "renormalized chemical potential = {50.0, 100.0, 200.0, 300.0, 400.0, 500.0};\n" "temperature = {1.0, 5.0, 7.0, 10.0, 20.0, 35.0};\n"); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark Entropy // The entropy only depends on the kinectic term, so it does // have a 'closed' form. Here we use it to calculate the entropy // for a few parameters values just to see if we get a well // behaved solution. if (true) { printf("\tEntropy\n"); SetFilePath("tests/entropy/data/"); SetParametersSet("BuballaR_2"); int n_pts = 1000; double temperature[4] = {1.0, 5.0, 10.0, 15.0}; double renormalized_chemical_potential[4] = {50.0, 100.0, 200.0, 350.0}; double mass_min = 0.0; double mass_max = 400.0; double mass_step = (mass_max - mass_min) / (double)(n_pts - 1); gsl_vector * mass_vector = gsl_vector_alloc(n_pts); gsl_vector * entropy_vector = gsl_vector_alloc(n_pts); for (int i = 0; i < 4; i++){ for (int j = 0; j < 4; j++){ double mass = mass_min; for (int k = 0; k < n_pts; k++){ double entropy = Entropy(mass, temperature[i], renormalized_chemical_potential[j]); gsl_vector_set(mass_vector, k, mass); gsl_vector_set(entropy_vector, k, entropy); mass += mass_step; } char filename[256]; sprintf(filename, "entropy_%d_%d.dat", i, j); WriteVectorsToFile(filename, "# mass, entropy\n", 2, mass_vector, entropy_vector); } } gsl_vector_free(mass_vector); gsl_vector_free(entropy_vector); SetFilePath("tests/entropy/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "The entropy only depends on the kinectic term, so it does\n" "have a 'closed' form. Here we use it to calculate the entropy\n" "for a few parameters values just to see if we get a well\n" "behaved solution.\n"); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark Reproduce Fig. 2.7 from Buballa Physics Reports if (true) { printf("\tReproduce Fig. 2.7 from Buballa Physics Reports\n"); SetFilePath("tests/Buballa-Fig2.7/data/"); SetParametersSet("BuballaR_2"); int n_pts = 1000; double temperature_min = 0.0; double temperature_max = 300.0; double temperature_step = (temperature_max - temperature_min) / (double)(n_pts - 1); gsl_vector * temperature_vector = gsl_vector_alloc(n_pts); gsl_vector * mass_vector = gsl_vector_alloc(n_pts); double temperature = temperature_min; for (int i = 0; i < n_pts; i++){ parameters.finite_temperature.temperature = temperature; // Prepare function to be passed to the root finding algorithm gsl_function F; F.function = &ZeroedGapEquationForFiniteTemperatureTest; double mass; int status = UnidimensionalRootFinder(&F, 0.0, 500.0, 1.0E-7, 1.0E-7, 1000, &mass); if (status == -1) mass = 0; gsl_vector_set(temperature_vector, i, temperature); gsl_vector_set(mass_vector, i, mass); temperature += temperature_step; } WriteVectorsToFile("mass_temperature.dat", "# Reproduce Fig. 2.7 from Buballa, Physics Reports bare_mass not zero\n" "# temperature, mass\n", 2, temperature_vector, mass_vector); // Repeat for bare_mass = 0 parameters.model.bare_mass = 0; temperature = temperature_min; for (int i = 0; i < n_pts; i++){ // FIXME: change the program to allow temperature as a variable // instead of as a parameter parameters.finite_temperature.temperature = temperature; // Prepare function to be passed to the root finding algorithm gsl_function F; F.function = &ZeroedGapEquationForFiniteTemperatureTest; // This case will not have solutions beyond T = 220 MeV double mass = 0; if (temperature < 220.0){ int status = UnidimensionalRootFinder(&F, 0.1, 500.0, 1.0E-7, 1.0E-7, 6000, &mass); if (status == -1) mass = 0; } gsl_vector_set(temperature_vector, i, temperature); gsl_vector_set(mass_vector, i, mass); temperature += temperature_step; } WriteVectorsToFile("mass_temperature_bare_mass_zero.dat", "# Reproduce Fig. 2.7 from Buballa, Physics Reports bare_mass = 0\n" "# temperature, mass\n", 2, temperature_vector, mass_vector); gsl_vector_free(temperature_vector); gsl_vector_free(mass_vector); SetFilePath("tests/Buballa-Fig2.7/"); FILE * log_file = OpenFile("run.log"); fprintf(log_file, "Reproduce Fig. 2.7 from Buballa Physics Reports\n"); PrintParametersToFile(log_file); fclose(log_file); SetFilePath(NULL); } #pragma mark Test root finding for renormalized chemical potential // After we reach the zero mass case, we use a onedimensional root finding // to determine the renormalized chemical potential. However, for some // reason the results seems to reach a maximum value. After this maximum, // the root finding will fail. One possibility is that we reach a maximum // value for the integral. if (true) { printf("\tTest root finding for renormalized chemical potential\n"); SetFilePath("tests/renorm-chem-pot-transient/data/"); SetParametersSet("Buballa_1"); int num_pts = 1000; double mass = 0; double barionic_density[12] = {0.1, 0.5, 0.7, 1.0, 1.4, 2.0, 2.1, 2.2, 2.3, 2.35, 2.4, 2.5}; // Range of chemical potential which will be tested double renorm_chem_pot_min = 0.0; double renorm_chem_pot_max = 3000; double step = (renorm_chem_pot_max - renorm_chem_pot_min) / (double)(num_pts - 1); gsl_vector * renorm_chem_pot_vector = gsl_vector_alloc(num_pts); gsl_vector * zeroed_dens_eq_vector = gsl_vector_alloc(num_pts); for (int i = 0; i < 12; i++){ double mu_r = renorm_chem_pot_min; for (int j = 0; j < num_pts; j++){ gsl_vector_set(renorm_chem_pot_vector, j, mu_r); double zeroed_dens_eq = ZeroedBarionicDensityEquationForFiniteTemperature(mass, mu_r, &(barionic_density[i])); gsl_vector_set(zeroed_dens_eq_vector, j, zeroed_dens_eq); mu_r += step; } char filename[256]; sprintf(filename, "zeroed_dens_eq_bar_dens_%d.dat", i); WriteVectorsToFile(filename, "# renormalized chemical potential, zeroed density equation \n", 2, renorm_chem_pot_vector, zeroed_dens_eq_vector); } SetFilePath(NULL); } }
INISetting::INISetting(LPCTSTR szINIFilePath) { m_pBuffer=NULL; SetFilePath(szINIFilePath); }
void FileStream::OpenForRead(const Path& path) { SetFilePath(path); m_File->Open(OpenMode::Read); SetDirection(StreamDirection::In); }
FilePath::FilePath(std::string file) { SetFilePath(file); }
void FileStream::OpenForWrite(const Path& path) { SetFilePath(path); m_File->Open(OpenMode::Write); SetDirection(StreamDirection::Out); }